@webda/core 1.6.0-beta.3 → 2.0.0-beta.0

package/lib/application.js

@@ -1,62 +1,27 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Application = exports.DefaultSchemaResolver = void 0;
-const child_process_1 = require("child_process");
+exports.Application = exports.SectionEnum = void 0;
 const fs = require("fs");
-const glob = require("glob");
-const merge = require("merge");
 const path = require("path");
 const index_1 = require("./index");
 const workout_1 = require("@webda/workout");
-const abstractdeployer_1 = require("./utils/abstractdeployer");
-const deepmerge = require("deepmerge");
-const semver = require("semver");
-const dateFormat = require("dateformat");
 const serializers_1 = require("./utils/serializers");
-const echo_1 = require("./services/echo");
-const cron_1 = require("./services/cron");
-const invitationservice_1 = require("./services/invitationservice");
-const notificationservice_1 = require("./services/notificationservice");
-/**
- * Implement the default way of retrieving schema
- */
-class DefaultSchemaResolver {
-    constructor(app) {
-        this.app = app;
-    }
-    fromServiceType(type = "") {
-        if (this.app.isCached()) {
-            return this.app.getConfiguration().cachedModules.schemas[type];
-        }
-        type = type.toLowerCase();
-        let proto = this.app.getDeployers()[type];
-        if (proto) {
-            return this.fromPrototype(proto);
-        }
-        proto = this.app.getServices()[type];
-        if (proto) {
-            return this.fromPrototype(proto);
-        }
-        proto = this.app.getModels()[type];
-        if (proto) {
-            return this.fromPrototype(proto);
-        }
-        return undefined;
-    }
-    fromPrototype(type) {
-        if (type && typeof type.getSchema === "function") {
-            return type.getSchema();
-        }
-        return undefined;
-    }
-}
-exports.DefaultSchemaResolver = DefaultSchemaResolver;
+var SectionEnum;
+(function (SectionEnum) {
+    SectionEnum["Moddas"] = "moddas";
+    SectionEnum["Deployers"] = "deployers";
+    SectionEnum["Models"] = "models";
+    SectionEnum["Beans"] = "beans";
+})(SectionEnum = exports.SectionEnum || (exports.SectionEnum = {}));
 /**
  * Map a Webda Application
  *
@@ -76,21 +41,12 @@ class Application {
      * @param {string} fileOrFolder to load Webda Application from
      * @param {Logger} logger
      */
-    constructor(file, logger = undefined, allowModule = false) {
-        /**
-         * Contains all definitions from imported modules and current code
-         */
-        this.cachedModules = {
-            services: {},
-            models: {},
-            deployers: {},
-            sources: []
-        };
+    constructor(file, logger = undefined) {
         /**
          * Contains definitions of current application
          */
         this.appModule = {
-            services: {},
+            moddas: {},
             models: {},
             deployers: {}
         };
@@ -103,58 +59,13 @@ class Application {
          */
         this.deployers = {};
         /**
-         * Services type registry
+         * Moddas registry
          */
-        this.services = {
-            // real service - modda
-            "webda/aggregator": index_1.AggregatorService,
-            "webda/asyncevents": index_1.EventService,
-            "webda/authentication": index_1.Authentication,
-            "webda/consolelogger": index_1.ConsoleLoggerService,
-            "webda/configurationservice": index_1.ConfigurationService,
-            "webda/cronservice": cron_1.CronService,
-            "webda/debugmailer": index_1.DebugMailer,
-            "webda/echoservice": echo_1.EchoService,
-            "webda/filebinary": index_1.FileBinary,
-            "webda/fileconfigurationservice": index_1.FileConfigurationService,
-            "webda/filequeue": index_1.FileQueue,
-            "webda/filestore": index_1.FileStore,
-            "webda/invitationservice": invitationservice_1.default,
-            "webda/kubernetesconfigurationservice": index_1.KubernetesConfigurationService,
-            "webda/mailer": index_1.Mailer,
-            "webda/mapper": index_1.MapperService,
-            "webda/memorylogger": index_1.MemoryLoggerService,
-            "webda/memoryqueue": index_1.MemoryQueue,
-            "webda/memorystore": index_1.MemoryStore,
-            "webda/multinotification": notificationservice_1.default,
-            "webda/resourceservice": index_1.ResourceService,
-            "webda/versionservice": index_1.VersionService
-        };
+        this.moddas = {};
         /**
          * Models type registry
          */
-        this.models = {
-            // Models
-            "webda/aclmodel": index_1.AclModel,
-            "webda/coremodel": index_1.CoreModel,
-            "webda/ident": index_1.Ident,
-            "webda/user": index_1.User,
-            "webdacore/context": index_1.Context,
-            "webdacore/securecookie": index_1.SecureCookie,
-            "webdacore/sessioncookie": index_1.SessionCookie
-        };
-        /**
-         * Flag if application has been compiled already
-         */
-        this.compiled = false;
-        /**
-         * Contains package.json of application
-         */
-        this.packageDescription = {};
-        /**
-         * Contains webda section of package.json and workspaces if exist
-         */
-        this.packageWebda = {};
+        this.models = {};
         /**
          * Detect if running as workspace
          */
@@ -162,90 +73,70 @@ class Application {
         this.logger = logger || new workout_1.WorkerOutput();
         this.initTime = Date.now();
         if (!fs.existsSync(file)) {
-            throw new index_1.WebdaError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.json file: unexisting ${file}`);
+            throw new index_1.WebdaError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.jsonc or webda.config.json file: unexisting ${file}`);
         }
         if (fs.lstatSync(file).isDirectory()) {
-            file = path.join(file, "webda.config.json");
+            file = path.join(file, "webda.config.jsonc");
+            if (!fs.existsSync(file)) {
+                file = file.substring(0, file.length - 1);
+            }
         }
+        this.configurationFile = file;
+        this.appPath = path.dirname(file);
+    }
+    /**
+     * Import all required modules
+     */
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loadConfiguration(this.configurationFile);
+            yield this.loadModule(this.baseConfiguration.cachedModules);
+            return this;
+        });
+    }
+    /**
+     * Allow subclass to implement migration
+     *
+     * @param file
+     * @returns
+     */
+    loadConfiguration(file) {
         // Check if file is a file or folder
-        if (!fs.existsSync(file) && !allowModule) {
-            throw new index_1.WebdaError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.json file: ${file}`);
+        if (!fs.existsSync(file)) {
+            throw new index_1.WebdaError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.jsonc or webda.config.json file: ${file}`);
         }
-        this.appPath = path.dirname(file);
         try {
-            this.baseConfiguration = JSON.parse(fs.readFileSync(file).toString());
-        }
-        catch (err) {
-            this.log("WARN", err);
-            if (allowModule) {
-                this.baseConfiguration = { version: 2, module: {} };
-            }
-            else {
-                throw new index_1.WebdaError("INVALID_WEBDA_CONFIG", `Cannot parse JSON of: ${file}`);
+            this.baseConfiguration = serializers_1.FileUtils.load(file);
+            if (this.baseConfiguration.version !== 3) {
+                this.log("ERROR", "Your configuration file should use version 3, see https://docs.webda.io/");
             }
         }
-        // Load default schema resolver
-        this.schemaResolver = new DefaultSchemaResolver(this);
-        // Migrate if needed
-        if (!this.baseConfiguration.version) {
-            this.baseConfiguration = this.migrateV0Config(this.baseConfiguration);
-        }
-        if (this.baseConfiguration.version == 1) {
-            this.baseConfiguration = this.migrateV1Config(this.baseConfiguration);
-        }
-        // Load if a module definition is included
-        if (this.baseConfiguration.module) {
-            this.loadModule(this.baseConfiguration.module, this.appPath);
-        }
-        // Load cached modules if there
-        if (this.baseConfiguration.cachedModules) {
-            this.loadModule(this.baseConfiguration.cachedModules, this.appPath);
-            // Import all modules sources to include any annotation
-            if (this.baseConfiguration.cachedModules.sources) {
-                this.baseConfiguration.cachedModules.sources.forEach(src => {
-                    require(path.join(process.cwd(), src));
-                });
-            }
+        catch (err) {
+            throw new index_1.WebdaError("INVALID_WEBDA_CONFIG", `Cannot parse JSON of: ${file}`);
         }
-        this.loadPackageInfos();
-        this.namespace = this.packageDescription.webda
-            ? this.packageDescription.webda.namespace
-            : this.packageDescription.name | this.packageDescription.name;
     }
     /**
      *
      * @param proto Prototype to send
      */
     getFullNameFromPrototype(proto) {
-        for (let i in this.services) {
-            if (this.services[i].prototype === proto) {
-                return i;
-            }
-        }
-        for (let i in this.deployers) {
-            if (this.deployers[i].prototype === proto) {
-                return i;
-            }
-        }
-        for (let i in this.models) {
-            if (this.models[i].prototype === proto) {
-                return i;
+        for (let section in SectionEnum) {
+            for (let i in this[SectionEnum[section]]) {
+                if (this[SectionEnum[section]][i] && this[SectionEnum[section]][i].prototype === proto) {
+                    return i;
+                }
             }
         }
     }
     /**
-     * Set the current schema resolver
+     * Get a schema from a type
      *
-     * @param resolver
+     * Schema should be precomputed in the default app
+     * @param type
+     * @returns
      */
-    setSchemaResolver(resolver) {
-        this.schemaResolver = resolver;
-    }
-    /**
-     * Get schema resolver
-     */
-    getSchemaResolver() {
-        return this.schemaResolver;
+    getSchema(type) {
+        return this.baseConfiguration.cachedModules.schemas[type];
     }
     /**
      * Check if application has cached modules
@@ -255,46 +146,7 @@ class Application {
      * take the schema from the cached modules also
      */
     isCached() {
-        return this.baseConfiguration.cachedModules !== undefined;
-    }
-    /**
-     * Check package.json
-     */
-    loadPackageInfos() {
-        let packageJson = path.join(this.appPath, "package.json");
-        if (fs.existsSync(packageJson)) {
-            this.packageDescription = JSON.parse(fs.readFileSync(packageJson).toString());
-        }
-        else {
-            this.log("WARN", "Application does not have a package.json");
-            return;
-        }
-        this.packageWebda = this.packageDescription.webda || {};
-        let parent = path.join(this.appPath, "..");
-        do {
-            packageJson = path.join(parent, "package.json");
-            if (fs.existsSync(packageJson)) {
-                let info = JSON.parse(fs.readFileSync(packageJson).toString());
-                if (info.workspaces) {
-                    this.log("DEBUG", "Application is running within a workspace");
-                    this.workspacesPath = path.resolve(parent);
-                    // Replace any relative path by absolute one
-                    for (let i in info.webda) {
-                        if (info.webda[i].startsWith("./")) {
-                            info.webda[i] = path.resolve(parent) + "/" + info.webda[i].substr(2);
-                        }
-                    }
-                    this.packageWebda = deepmerge(info.webda || {}, this.packageWebda);
-                    this.packageWebda.workspaces = {
-                        packages: info.workspaces,
-                        parent: info,
-                        path: path.resolve(parent)
-                    };
-                    return;
-                }
-            }
-            parent = path.join(parent, "..");
-        } while (path.resolve(parent) !== "/");
+        return true;
     }
     /**
      * Retrieve specific webda conf from package.json
@@ -302,82 +154,17 @@ class Application {
      * In case of workspaces the object is combined
      */
     getPackageWebda() {
-        return this.packageWebda;
+        var _a;
+        return (((_a = this.baseConfiguration.cachedModules.project) === null || _a === void 0 ? void 0 : _a.webda) || {
+            namespace: "Webda"
+        });
     }
     /**
      * Retrieve content of package.json
      */
     getPackageDescription() {
-        return this.packageDescription;
-    }
-    /**
-     * Set the status of the compilation
-     *
-     * @param compile true will avoid trigger new compilation
-     */
-    preventCompilation(compile) {
-        this.compiled = compile;
-    }
-    /**
-     * Migrate from v0 to v1 configuration
-     *
-     * A V0 is a webda.config.json that does not contain any version tag
-     *
-     * @param config
-     */
-    migrateV0Config(config) {
-        this.log("WARN", "Old V0 webda.config.json format, trying to migrate");
-        let newConfig = {
-            parameters: {},
-            services: {},
-            models: {},
-            routes: {},
-            version: 1
-        };
-        let domain;
-        if (config["*"]) {
-            domain = config[config["*"]];
-        }
-        else {
-            domain = config[Object.keys(config)[0]] || { global: {} };
-        }
-        if (domain.global) {
-            newConfig.parameters = domain.global.params || {};
-            newConfig.services = domain.global.services || {};
-            newConfig.models = domain.global.models || {};
-            newConfig.parameters.locales = domain.global.locales;
-            newConfig.moddas = domain.global.moddas || {};
-        }
-        for (let i in domain) {
-            if (i === "global")
-                continue;
-            newConfig.routes[i] = domain[i];
-        }
-        return newConfig;
-    }
-    /**
-     * Migrate from v1 to v2 configuration format
-     *
-     * @param config
-     */
-    migrateV1Config(config) {
-        this.log("WARN", "Old V1 webda.config.json format, trying to migrate");
-        let newConfig = {
-            parameters: config.parameters,
-            services: config.services,
-            module: {
-                services: {},
-                models: Object.assign({}, config.models),
-                deployers: {}
-            },
-            version: 2
-        };
-        if (config.moddas) {
-            for (let i in config.moddas) {
-                newConfig.module.services[i] = config.moddas[i].require;
-            }
-        }
-        return newConfig;
+        var _a, _b;
+        return ((_b = (_a = this.baseConfiguration.cachedModules) === null || _a === void 0 ? void 0 : _a.project) === null || _b === void 0 ? void 0 : _b.package) || {};
     }
     /**
      * Log information
@@ -418,30 +205,45 @@ class Application {
      */
     addService(name, service) {
         this.log("TRACE", "Registering service", name);
-        this.services[name.toLowerCase()] = service;
+        this.moddas[name.toLowerCase()] = service;
+        return this;
     }
     /**
-     * Get a service based on name
      *
+     * @param section
      * @param name
+     * @returns
      */
-    getService(name) {
-        let serviceName = this.completeNamespace(name).toLowerCase();
-        this.log("TRACE", "Search for service", serviceName);
-        if (!this.services[serviceName]) {
-            serviceName = `Webda/${name}`.toLowerCase();
-            // Try Webda namespace
-            if (!this.services[serviceName]) {
-                throw Error("Undefined service " + name);
-            }
+    getWebdaObject(section, name) {
+        let objectName = this.completeNamespace(name);
+        this.log("TRACE", `Search for ${section} ${objectName}`);
+        if (!this[section][objectName] && name.indexOf("/") === -1) {
+            objectName = `webda/${name}`.toLowerCase();
+        }
+        if (!this[section][objectName]) {
+            throw Error(`Undefined ${section.substring(0, section.length - 1)} ${name} or ${objectName} (${Object.keys(this[section]).join(", ")})`);
         }
-        return this.services[serviceName];
+        return this[section][objectName];
+    }
+    /**
+     * Get a service based on name
+     *
+     * @param name
+     */
+    getModda(name) {
+        return this.getWebdaObject("moddas", name);
     }
     /**
      * Return all services of the application
      */
-    getServices() {
-        return this.services;
+    getModdas() {
+        return this.moddas;
+    }
+    /**
+     * Return all beans of the application
+     */
+    getBeans() {
+        return this.baseConfiguration.cachedModules.beans;
     }
     /**
      * Retrieve the model implementation
@@ -449,14 +251,7 @@ class Application {
      * @param name model to retrieve
      */
     getModel(name) {
-        name = name.toLowerCase();
-        if (name.indexOf("/") < 0) {
-            name = `webda/${name}`;
-        }
-        if (!this.models[name.toLowerCase()]) {
-            throw Error("Undefined model '" + name + "' known models are '" + Object.keys(this.models).join(",") + "'");
-        }
-        return this.models[name.toLowerCase()];
+        return this.getWebdaObject("models", name);
     }
     /**
      * Get all models definitions
@@ -479,6 +274,7 @@ class Application {
     addModel(name, model) {
         this.log("TRACE", "Registering model", name);
         this.models[name.toLowerCase()] = model;
+        return this;
     }
     /**
      * Add a new deployer
@@ -489,16 +285,7 @@ class Application {
     addDeployer(name, model) {
         this.log("TRACE", "Registering deployer", name);
         this.deployers[name.toLowerCase()] = model;
-    }
-    /**
-     * Check if a deployment exists for this application
-     * This method cannot be called for a packaged application
-     * as we do not keep deployments files when deployed
-     *
-     * @param deploymentName
-     */
-    hasDeployment(deploymentName) {
-        return fs.existsSync(path.join(this.appPath, "deployments", deploymentName + ".json"));
+        return this;
     }
     /**
      * Return webda current version
@@ -509,76 +296,15 @@ class Application {
     getWebdaVersion() {
         return JSON.parse(fs.readFileSync(__dirname + "/../package.json").toString()).version;
     }
-    getDeployment(deploymentName = undefined) {
-        if (!deploymentName) {
-            deploymentName = this.currentDeployment;
-        }
-        let deploymentConfig = path.join(this.appPath, "deployments", deploymentName + ".json");
-        // Load deployment
-        if (!fs.existsSync(deploymentConfig)) {
-            throw new index_1.WebdaError("UNKNOWN_DEPLOYMENT", "Unknown deployment");
-        }
-        let deploymentModel;
-        try {
-            deploymentModel = JSON.parse(fs.readFileSync(deploymentConfig).toString());
-            deploymentModel.name = deploymentName;
-        }
-        catch (err) {
-            throw new index_1.WebdaError("INVALID_DEPLOYMENT", `Invalid deployment configuration ${deploymentConfig}: ${err.toString()}`);
-        }
-        return deploymentModel;
-    }
     /**
      * Retrieve Git Repository information
      *
      * {@link GitInformation} for more details on how the information is gathered
      * @return the git information
      */
-    getGitInformation() {
-        let options = {
-            cwd: this.getAppPath()
-        };
-        let info = this.getPackageDescription();
-        try {
-            let tags = (0, child_process_1.execSync)(`git tag --points-at HEAD`, options)
-                .toString()
-                .trim()
-                .split("\n")
-                .filter(t => t !== "");
-            let tag = "";
-            let version = info.version;
-            if (tags.includes(`${info.name}@${info.version}`)) {
-                tag = `${info.name}@${info.version}`;
-            }
-            else if (tags.includes(`v${info.version}`)) {
-                tag = `v${info.version}`;
-            }
-            else {
-                version = semver.inc(info.version, "patch") + "+" + dateFormat(new Date(), "yyyymmddHHMMssl");
-            }
-            // Search for what would be the tag
-            // packageName@version
-            // or version if single repo
-            // if not included create a nextVersion+SNAPSHOT.${commit}.${now}
-            return {
-                commit: (0, child_process_1.execSync)(`git rev-parse HEAD`, options).toString().trim(),
-                branch: (0, child_process_1.execSync)("git symbolic-ref --short HEAD", options).toString().trim(),
-                short: (0, child_process_1.execSync)(`git rev-parse --short HEAD`, options).toString().trim(),
-                tag,
-                tags,
-                version
-            };
-        }
-        catch (err) {
-            return {
-                commit: "unknown",
-                branch: "unknown",
-                tag: "",
-                short: "00000000",
-                tags: [],
-                version: info.version
-            };
-        }
+    getGitInformation(_packageName, _version) {
+        var _a;
+        return (_a = this.baseConfiguration.cachedModules.project) === null || _a === void 0 ? void 0 : _a.git;
     }
     /**
      * Allow variable inside of string
@@ -591,7 +317,7 @@ class Application {
         if (templateString.indexOf("${") < 0) {
             return templateString;
         }
-        return new Function("return `" + templateString.replace(/\$\{/g, "${this.") + "`;").call(Object.assign({ package: this.getPackageDescription(), git: this.getGitInformation(), deployment: this.getCurrentDeployment(), now: this.initTime }, replacements));
+        return new Function("return `" + templateString.replace(/\$\{/g, "${this.") + "`;").call(Object.assign(Object.assign(Object.assign({}, this.baseConfiguration.cachedModules.project), { now: this.initTime }), replacements));
     }
     /**
      * Allow variable inside object strings
@@ -642,75 +368,26 @@ class Application {
         }));
     }
     /**
-     * Return the application Configuration for a deployment
-     *
-     * Given this inputs:
-     *
-     * webda.config.json
-     * ```json
-     * {
-     *  "parameters": {
-     *    "param3": "test"
-     *  },
-     *  "services": {
-     *    "MyService": {
-     *      "param1": {
-     *        "sub": "test"
-     *      },
-     *      "param2": "value"
-     *    }
-     *  }
-     * }
-     * ```
-     *
-     * deployment.json
-     * ```json
-     * {
-     *  "parameters": {
-     *    "param4": "deployment"
-     *  }
-     *  "services": {
-     *    "MyService": {
-     *      "param1": {
-     *        "sub2": "deploymentSub"
-     *      },
-     *      "param2": "${package.version}"
-     *    }
-     *  }
-     * }
-     * ```
-     *
-     * The result would be:
-     * ```json
-     * {
-     *  "parameters": {
-     *    "param3": "test",
-     *    "param4": "deployment"
-     *  },
-     *  "services": {
-     *    "MyService": {
-     *      "param1": {
-     *        "sub": "test",
-     *        "sub2": "deploymentSub"
-     *      },
-     *      "param2": "1.1.0"
-     *    }
-     *  }
-     * }
-     * ```
-     * This map can also use parameters {@link replaceVariables}
+     * Get current deployment name
+     */
+    getCurrentDeployment() {
+        return this.baseConfiguration.cachedModules.project.deployment.name;
+    }
+    /**
+     * Return all application modules merged as one
      *
-     * @param deploymentName to use for the Configuration
+     * Used when deployed
+     * @returns
      */
-    getConfiguration(deploymentName = undefined) {
-        if (!deploymentName) {
-            return this.baseConfiguration;
-        }
-        let config = JSON.parse(JSON.stringify(this.baseConfiguration));
-        let deploymentModel = this.getDeployment(deploymentName);
-        config.parameters = this.replaceVariables(merge.recursive(config.parameters, deploymentModel.parameters));
-        config.services = this.replaceVariables(merge.recursive(config.services, deploymentModel.services));
-        return config;
+    getModules() {
+        return this.baseConfiguration.cachedModules;
+    }
+    /**
+     * Get application configuration
+     * @returns
+     */
+    getConfiguration(_deployment = undefined) {
+        return this.baseConfiguration;
     }
     /**
      * Return current Configuration of the Application
@@ -722,132 +399,7 @@ class Application {
      * ```
      */
     getCurrentConfiguration() {
-        return this.getConfiguration(this.currentDeployment);
-    }
-    /**
-     * Set the current deployment for the application
-     * Call to getCurrentConfiguration will resolve to the computed configuration for the deployment
-     * If needed, you can call the method with undefined to reset to default configuration
-     *
-     * @param deployment to set
-     */
-    setCurrentDeployment(deployment) {
-        this.currentDeployment = deployment;
-    }
-    /**
-     * Get current deployment name
-     */
-    getCurrentDeployment() {
-        return this.currentDeployment;
-    }
-    /**
-     * Compile the application if it is a Typescript application
-     * Do nothing otherwise
-     */
-    compile() {
-        if (this.compiled) {
-            return;
-        }
-        // exec typescript
-        this.log("DEBUG", "Compiling application");
-        try {
-            (0, child_process_1.execSync)(`tsc -p ${this.appPath}`);
-        }
-        catch (err) {
-            (err.stdout.toString() + err.stderr.toString())
-                .split("\n")
-                .filter(l => l !== "")
-                .forEach(l => {
-                this.log("ERROR", "tsc:", l);
-            });
-        }
-        this.compiled = true;
-    }
-    /**
-     * Load all imported modules and current module
-     * It will compile module
-     * Generate the current module file
-     * Load any imported webda.module.json
-     */
-    loadModules() {
-        // Cached modules is defined on deploy
-        if (this.baseConfiguration.cachedModules) {
-            // We should not load any modules as we are in a deployed version
-            return;
-        }
-        // Compile
-        this.compile();
-        const Finder = require("fs-finder");
-        // Modules should be cached on deploy
-        var files = [];
-        let nodeModules = path.join(this.appPath, "node_modules");
-        if (fs.existsSync(nodeModules)) {
-            files = Finder.from(nodeModules).findFiles("webda.module.json");
-        }
-        // Search workspace for webda.module.json
-        if (this.workspacesPath !== "") {
-            nodeModules = path.join(this.workspacesPath, "node_modules");
-            if (fs.existsSync(nodeModules)) {
-                files.push(...Finder.from(nodeModules).findFiles("webda.module.json"));
-            }
-        }
-        // Generate module
-        this.generateModule();
-        let currentModule = path.join(this.appPath, "webda.module.json");
-        if (fs.existsSync(currentModule)) {
-            files.push(currentModule);
-        }
-        if (files.length) {
-            this.log("DEBUG", "Found modules", files);
-            files.forEach(file => {
-                let info = require(file);
-                this.loadModule(info, path.dirname(file));
-            });
-        }
-    }
-    getModules() {
-        return this.cachedModules;
-    }
-    /**
-     * Generate the module for current application
-     */
-    generateModule() {
-        // Compile
-        this.compile();
-        // Reinit the sources cache
-        this.cachedModules.sources = [];
-        this._loaded = [];
-        // Read all files
-        this.getPackagesLocations().forEach(p => {
-            let absPath = path.resolve(path.join(this.appPath, p));
-            if (this._loaded.indexOf(absPath) >= 0) {
-                return;
-            }
-            this._loaded.push(absPath);
-            if (fs.existsSync(absPath) && fs.lstatSync(absPath).isDirectory()) {
-                absPath += "/**/*.js";
-            }
-            glob.sync(absPath).forEach(f => this.loadJavascriptFile(f));
-        });
-        let moduleFile = path.join(this.appPath, "webda.module.json");
-        let current = "";
-        if (fs.existsSync(moduleFile)) {
-            current = fs.readFileSync(moduleFile).toString();
-        }
-        let module = Object.assign(Object.assign({}, this.appModule), { schemas: {} });
-        for (let i in this.appModule.services) {
-            module.schemas[i] = this.getSchemaResolver().fromPrototype(this.services[i.toLowerCase()]);
-        }
-        for (let i in this.appModule.deployers) {
-            module.schemas[i] = this.getSchemaResolver().fromPrototype(this.deployers[i.toLowerCase()]);
-        }
-        for (let i in this.appModule.models) {
-            module.schemas[i] = this.getSchemaResolver().fromPrototype(this.models[i.toLowerCase()]);
-        }
-        if (current !== serializers_1.JSONUtils.stringify(module, undefined, 2)) {
-            // Write module
-            serializers_1.FileUtils.save(module, moduleFile);
-        }
+        return this.getConfiguration();
     }
     /**
      * Import a file
@@ -856,32 +408,35 @@ class Application {
      *
      * @param info
      */
-    resolveRequire(info) {
-        if (info.startsWith(".")) {
-            info = this.appPath + "/" + info;
-        }
-        try {
-            let serviceConstructor = require(info);
-            if (serviceConstructor.default) {
-                return serviceConstructor.default;
+    importFile(info) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (info.startsWith(".")) {
+                info = this.appPath + "/" + info;
             }
-            else {
-                return serviceConstructor;
+            try {
+                this.log("TRACE", "Load file", info);
+                const [importFilename, importName = "default"] = info.split(":");
+                const importObject = (yield Promise.resolve().then(() => require(importFilename)))[importName];
+                if (!importObject) {
+                    this.log("WARN", `Module ${importFilename} does not have export named ${importName}`);
+                }
+                return importObject;
             }
-        }
-        catch (err) {
-            this.log("WARN", "Cannot resolve require", info, err.message);
-            return null;
-        }
+            catch (err) {
+                this.log("WARN", "Cannot resolve require", info, err.message);
+            }
+        });
     }
     /**
      * Load local module
      */
     loadLocalModule() {
-        let moduleFile = path.join(process.cwd(), "webda.module.json");
-        if (fs.existsSync(moduleFile)) {
-            this.loadModule(JSON.parse(fs.readFileSync(moduleFile).toString()), process.cwd());
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            let moduleFile = path.join(process.cwd(), "webda.module.json");
+            if (fs.existsSync(moduleFile)) {
+                yield this.loadModule(JSON.parse(fs.readFileSync(moduleFile).toString()), process.cwd());
+            }
+        });
     }
     /**
      * Load the module,
@@ -889,40 +444,26 @@ class Application {
      * @protected
      * @ignore Useless for documentation
      */
-    loadModule(info, parent = this.appPath) {
-        info.services = info.services || {};
-        info.models = info.models || {};
-        info.deployers = info.deployers || {};
-        // Load services definition
-        for (let key in info.services) {
-            let service = this.resolveRequire(path.join(parent, info.services[key]));
-            if (!service) {
-                continue;
-            }
-            this.addService(key, service);
-            this.cachedModules.services[key] =
-                "./" + path.relative(this.appPath, path.resolve(path.join(parent, info.services[key])));
-        }
-        // Load models definition
-        for (let key in info.models) {
-            let service = this.resolveRequire(path.join(parent, info.models[key]));
-            if (!service) {
-                continue;
-            }
-            this.addModel(key, service);
-            this.cachedModules.models[key] =
-                "./" + path.relative(this.appPath, path.resolve(path.join(parent, info.models[key])));
-        }
-        // Load deployers definition
-        for (let key in info.deployers) {
-            let service = this.resolveRequire(path.join(parent, info.deployers[key]));
-            if (!service) {
-                continue;
-            }
-            this.addDeployer(key, service);
-            this.cachedModules.deployers[key] =
-                "./" + path.relative(this.appPath, path.resolve(path.join(parent, info.deployers[key])));
-        }
+    loadModule(module, parent = this.appPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = Object.assign({ beans: {} }, module);
+            const sectionLoader = (section) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                var _b, _c;
+                for (let key in info[section]) {
+                    (_a = (_b = this[section])[_c = key.toLowerCase()]) !== null && _a !== void 0 ? _a : (_b[_c] = yield this.importFile(path.join(parent, info[section][key])));
+                }
+            });
+            yield Promise.all([
+                sectionLoader("moddas"),
+                sectionLoader("deployers"),
+                sectionLoader("models"),
+                ...Object.keys(info.beans).map(f => {
+                    this.baseConfiguration.cachedModules.beans[f] = info.beans[f];
+                    return Promise.resolve().then(() => require(path.join(parent, info.beans[f]))).catch(this.log.bind(this, "WARN"));
+                })
+            ]);
+        });
     }
     /**
      * Return the full name including namespace
@@ -934,11 +475,12 @@ class Application {
      * @param name
      */
     completeNamespace(name = "") {
+        var _a, _b;
         // Do not add a namespace if already present
         if (name.indexOf("/") >= 0) {
-            return name;
+            return name.toLowerCase();
         }
-        return `${this.namespace}/${name}`;
+        return `${((_b = (_a = this.baseConfiguration.cachedModules.project) === null || _a === void 0 ? void 0 : _a.webda) === null || _b === void 0 ? void 0 : _b.namespace) || "webda"}/${name}`.toLowerCase();
     }
     /**
      * Check if object extends a class
@@ -960,56 +502,6 @@ class Application {
         }
         return false;
     }
-    /**
-     * Load a javascript file and check for Modda
-     * @param path to load
-     */
-    loadJavascriptFile(absolutePath) {
-        let marker = path.resolve(absolutePath);
-        if (this._loaded.indexOf(marker) >= 0) {
-            return;
-        }
-        this._loaded.push(marker);
-        let source = "./" + path.relative(this.appPath, absolutePath);
-        if (this.cachedModules.sources.indexOf(source) < 0) {
-            this.cachedModules.sources.push(source);
-        }
-        let mod = this.resolveRequire(absolutePath);
-        let obj = mod;
-        if (obj && obj.getModda) {
-            let modda = mod.getModda();
-            let name = mod.prototype.name;
-            let category = "services";
-            if (modda) {
-                name = modda.uuid;
-                if (modda.category) {
-                    category = modda.category;
-                }
-            }
-            this.log("DEBUG", `Found new getModda implementation ${category} ${this.completeNamespace(name)}`);
-            this.appModule[category][this.completeNamespace(name)] = path.relative(this.appPath, absolutePath);
-            if (this.extends(obj, abstractdeployer_1.AbstractDeployer)) {
-                this.addDeployer(this.completeNamespace(name), obj);
-            }
-            else {
-                this.addService(this.completeNamespace(name), obj);
-            }
-        }
-        else if (this.extends(obj, index_1.CoreModel) || this.extends(obj, index_1.Context)) {
-            this.log("DEBUG", "Found new CoreModel implementation", this.completeNamespace(obj.name));
-            this.appModule["models"][this.completeNamespace(obj.name)] = path.relative(this.appPath, absolutePath);
-            this.addModel(this.completeNamespace(obj.name), obj);
-        }
-    }
-    /**
-     * Get the application files
-     */
-    getPackagesLocations() {
-        return this.packageDescription.files || ["lib/**/*.js"];
-    }
 }
-__decorate([
-    (0, index_1.Cache)()
-], Application.prototype, "getGitInformation", null);
 exports.Application = Application;
 //# sourceMappingURL=application.js.map