@webda/core 2.4.2 → 3.0.1

package/lib/core.js

@@ -6,7 +6,7 @@ import jsonpath from "jsonpath";
 import pkg from "node-machine-id";
 import { Counter, Gauge, Histogram, register } from "prom-client";
 import { v4 as uuidv4 } from "uuid";
-import { Context, Logger, Store, UnpackedApplication } from "./index.js";
+import { BinaryService, GlobalContext, Logger, OperationContext, Store, UnpackedApplication, WebContext, WebdaError, WebdaQL } from "./index.js";
 import { CoreModel } from "./models/coremodel.js";
 import { Router } from "./router.js";
 import { JSONUtils } from "./utils/serializers.js";
@@ -23,28 +23,13 @@ export class ValidationError extends Error {
     }
 }
 /**
- *
- */
-export class RegistryEntry extends CoreModel {
-}
-/**
- * Error with a code
+ * Operation
  */
-export class WebdaError extends Error {
-    /**
-     *
-     * @param code
-     * @param message
-     */
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-    /**
-     * Return error code
-     */
-    getCode() {
-        return this.code;
+export class OperationError extends Error {
+    constructor(operation, type) {
+        super(`Operation ${operation} ${type}`);
+        this.operation = operation;
+        this.type = type;
     }
 }
 /**
@@ -110,12 +95,14 @@ export class WebsiteOriginFilter {
         return false;
     }
 }
-const beans = {};
 // @Bean to declare as a Singleton service
 export function Bean(constructor) {
-    let name = constructor.name.toLowerCase();
-    beans[name] = beans[name] || { constructor };
-    beans[name] = { ...beans[name], bean: true };
+    let name = constructor.name;
+    // @ts-ignore
+    process.webdaBeans ?? (process.webdaBeans = {});
+    // @ts-ignore
+    const beans = process.webdaBeans;
+    beans[name] ?? (beans[name] = constructor);
 }
 /**
  * This is the main class of the framework, it handles the routing, the services initialization and resolution
@@ -128,7 +115,7 @@ export class Core extends events.EventEmitter {
      * @params {Object} config - The configuration Object, if undefined will load the configuration file
      */
     constructor(application) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         /** @ignore */
         super();
         /**
@@ -136,6 +123,10 @@ export class Core extends events.EventEmitter {
          * @hidden
          */
         this.services = {};
+        /**
+         * Webda Beans
+         */
+        this.beans = {};
         /**
          * Router that will route http request in
          */
@@ -170,10 +161,28 @@ export class Core extends events.EventEmitter {
          * Cache for model to store resolution
          */
         this._modelStoresCache = new Map();
+        /**
+         * Cache for model to store resolution
+         */
+        this._modelBinariesCache = new Map();
         /**
          * True if the dual import warning has been sent
          */
         this._dualImportWarn = false;
+        /**
+         * Registered context providers
+         */
+        this._contextProviders = [
+            {
+                getContext: (info) => {
+                    // If http is defined, return a WebContext
+                    if (info.http) {
+                        return new WebContext(this, info.http, info.stream);
+                    }
+                    return new OperationContext(this, info.stream);
+                }
+            }
+        ];
         // Store WebdaCore in process to avoid conflict with import
         // @ts-ignore
         Core.singleton = process.webda = this;
@@ -187,18 +196,17 @@ export class Core extends events.EventEmitter {
         this._ajvSchemas = {};
         // Load the configuration and migrate
         this.configuration = this.application.getCurrentConfiguration();
-        // Set the global context
-        Context.setGlobalContext(new (this.getModel(this.parameter("contextModel") || "Webda/Context"))(this));
         // Init default values for configuration
         (_a = this.configuration).parameters ?? (_a.parameters = {});
         (_b = this.configuration.parameters).apiUrl ?? (_b.apiUrl = "http://localhost:18080");
-        (_c = this.configuration.parameters).metrics ?? (_c.metrics = {});
+        (_c = this.configuration.parameters).defaultStore ?? (_c.defaultStore = "Registry");
+        (_d = this.configuration.parameters).metrics ?? (_d.metrics = {});
         if (this.configuration.parameters.metrics) {
-            (_d = this.configuration.parameters.metrics).labels ?? (_d.labels = {});
-            (_e = this.configuration.parameters.metrics).config ?? (_e.config = {});
-            (_f = this.configuration.parameters.metrics).prefix ?? (_f.prefix = "");
+            (_e = this.configuration.parameters.metrics).labels ?? (_e.labels = {});
+            (_f = this.configuration.parameters.metrics).config ?? (_f.config = {});
+            (_g = this.configuration.parameters.metrics).prefix ?? (_g.prefix = "");
         }
-        (_g = this.configuration).services ?? (_g.services = {});
+        (_h = this.configuration).services ?? (_h.services = {});
         // Add CSRF origins filtering
         if (this.configuration.parameters.csrfOrigins) {
             this.registerCORSFilter(new OriginFilter(this.configuration.parameters.csrfOrigins));
@@ -207,6 +215,7 @@ export class Core extends events.EventEmitter {
         if (this.configuration.parameters.website) {
             this.registerCORSFilter(new WebsiteOriginFilter(this.configuration.parameters.website));
         }
+        this.setGlobalContext(new GlobalContext(this));
     }
     /**
      * Get the singleton of Webda Core
@@ -227,21 +236,17 @@ export class Core extends events.EventEmitter {
      * @param model
      * @returns
      */
-    getModelStore(model) {
-        if (model instanceof CoreModel) {
-            if (this._modelStoresCache.has(model.__class)) {
-                return this._modelStoresCache.get(model.__class);
-            }
-        }
-        else if (this._modelStoresCache.has(model)) {
+    getModelStore(modelOrConstructor) {
+        const model = ((modelOrConstructor instanceof CoreModel ? modelOrConstructor.__class : modelOrConstructor));
+        if (this._modelStoresCache.has(model)) {
             return this._modelStoresCache.get(model);
         }
         const setCache = store => {
-            this._modelStoresCache.set(model instanceof CoreModel ? model.__class : model, store);
+            this._modelStoresCache.set(model, store);
         };
         const stores = this.getStores();
         let actualScore;
-        let actualStore = this.getService(this.parameter("defaultStore"));
+        let actualStore = this.getService(this.parameter("defaultStore") || "Registry");
         for (let store in stores) {
             let score = stores[store].handleModel(model);
             // As 0 mean exact match we stop there
@@ -257,6 +262,38 @@ export class Core extends events.EventEmitter {
         setCache(actualStore);
         return actualStore;
     }
+    /**
+     * Get the service that manage a model
+     * @param modelOrConstructor
+     * @param attribute
+     * @returns
+     */
+    getBinaryStore(modelOrConstructor, attribute) {
+        const binaries = this.getServicesOfType(BinaryService);
+        const model = this.application.getModelName(modelOrConstructor);
+        let actualScore = -1;
+        let actualService;
+        const setCache = store => {
+            this._modelBinariesCache.set(model, store);
+        };
+        for (let binary in binaries) {
+            let score = binaries[binary].handleBinary(model, attribute);
+            // As 0 mean exact match we stop there
+            if (score === 2) {
+                setCache(binaries[binary]);
+                return binaries[binary];
+            }
+            else if (score >= 0 && (actualService === undefined || actualScore > score)) {
+                actualScore = score;
+                actualService = binaries[binary];
+            }
+        }
+        if (!actualService) {
+            throw new Error("No binary store found for " + model + " " + attribute);
+        }
+        setCache(actualService);
+        return actualService;
+    }
     /**
      * Return Core instance id
      *
@@ -328,7 +365,7 @@ export class Core extends events.EventEmitter {
      * @param partials
      */
     async getModelObject(fullUuid, partials) {
-        return CoreModel.fromFullUuid(this, fullUuid, partials);
+        return CoreModel.fromFullUuid(fullUuid, this, partials);
     }
     /**
      * Init Webda
@@ -336,7 +373,6 @@ export class Core extends events.EventEmitter {
      * It will resolve Services init method and autolink
      */
     async init() {
-        var _a, _b;
         if (this._init) {
             return this._init;
         }
@@ -346,13 +382,13 @@ export class Core extends events.EventEmitter {
                 // Create the configuration service
                 this.createService(this.configuration.services, this.configuration.parameters.configurationService);
                 let cfg = await this.getService(this.configuration.parameters.configurationService).initConfiguration();
-                if (cfg.webda) {
-                    (_a = cfg.webda).parameters ?? (_a.parameters = {});
-                    (_b = cfg.webda).services ?? (_b.services = {});
-                    this.configuration.parameters = { ...this.configuration.parameters, ...cfg.webda.parameters };
+                if (cfg) {
+                    cfg.parameters ?? (cfg.parameters = {});
+                    cfg.services ?? (cfg.services = {});
+                    this.configuration.parameters = { ...this.configuration.parameters, ...cfg.parameters };
                     for (let i in this.configuration.services) {
                         this.configuration.services[i] = {
-                            ...deepmerge(this.configuration.services[i], cfg.webda.services[i] || {}),
+                            ...deepmerge(this.configuration.services[i], cfg.services[i] || {}),
                             type: this.configuration.services[i].type
                         };
                     }
@@ -366,10 +402,13 @@ export class Core extends events.EventEmitter {
         }
         // Init the other services
         this.initStatics();
+        // Reset the model cache
+        this._modelStoresCache.clear();
+        this._modelBinariesCache.clear();
         this.log("TRACE", "Create Webda init promise");
-        this._init = new Promise(async (resolve) => {
-            await this.initService("registry");
-            await this.initService("cryptoservice");
+        this._init = (async () => {
+            await this.initService("Registry");
+            await this.initService("CryptoService");
             // Init services
             let service;
             let inits = [];
@@ -382,8 +421,7 @@ export class Core extends events.EventEmitter {
             }
             await Promise.all(inits);
             await this.emitSync("Webda.Init.Services", this.services);
-            resolve();
-        });
+        })();
         return this._init;
     }
     /**
@@ -397,18 +435,54 @@ export class Core extends events.EventEmitter {
         });
     }
     /**
-     * Call an operation within the framework
+     * Check if an operation can be executed with the current context
+     * Not checking the input use `checkOperation` instead to check everything
+     * @param context
+     * @param operationId
+     * @throws OperationError if operation is unknown
+     * @returns true if operation can be executed
      */
-    async callOperation(context, operationId) {
+    checkOperationPermission(context, operationId) {
+        var _a;
         if (!this.operations[operationId]) {
-            throw new Error(`Unknown Operation Id: ${operationId}`);
+            throw new OperationError(operationId, "Unknown");
+        }
+        if (this.operations[operationId].permission) {
+            (_a = this.operations[operationId]).permissionQuery ?? (_a.permissionQuery = new WebdaQL.QueryValidator(this.operations[operationId].permission));
+            return this.operations[operationId].permissionQuery.eval(context.getSession());
+        }
+        return true;
+    }
+    /**
+     * Check if an operation can be executed with the current context
+     * @param context
+     * @param operationId
+     */
+    async checkOperation(context, operationId) {
+        if (!this.checkOperationPermission(context, operationId)) {
+            throw new OperationError(operationId, "PermissionDenied");
         }
         let input = await context.getInput();
-        this.log("TRACE", `Operation ${operationId} input is '${JSONUtils.safeStringify(input, undefined, 2)}'`);
-        if (this.operations[operationId].input &&
-            (input === undefined || this.validateSchema(this.operations[operationId].input, input) !== true)) {
-            throw new Error("Input does not fit the operation input");
+        this.log("TRACE", `Operation ${operationId} input is '${JSONUtils.safeStringify(input, undefined, 2)}' (schema: ${this.operations[operationId].input})`);
+        try {
+            if (this.operations[operationId].input &&
+                (input === undefined || this.validateSchema(this.operations[operationId].input, input) !== true)) {
+                throw new OperationError(operationId, "InvalidInput");
+            }
+        }
+        catch (err) {
+            if (err.message === "validation failed") {
+                throw new OperationError(operationId, "InvalidInput");
+            }
+            throw err;
         }
+    }
+    /**
+     * Call an operation within the framework
+     */
+    async callOperation(context, operationId) {
+        context.setExtension("operation", operationId);
+        await this.checkOperation(context, operationId);
         return this.getService(this.operations[operationId].service)[this.operations[operationId].method](context);
     }
     /**
@@ -419,9 +493,7 @@ export class Core extends events.EventEmitter {
         const list = {};
         Object.keys(this.operations).forEach(o => {
             list[o] = {
-                ...this.operations[o],
-                input: this.operations[o].input ? this.application.completeNamespace(this.operations[o].input) : undefined,
-                output: this.operations[o].output ? this.application.completeNamespace(this.operations[o].output) : undefined
+                ...this.operations[o]
             };
             delete list[o].service;
             delete list[o].method;
@@ -434,7 +506,17 @@ export class Core extends events.EventEmitter {
      * @param definition
      */
     registerOperation(operationId, definition) {
+        if (operationId.match(/[^a-zA-Z0-9.]/)) {
+            throw new Error("OperationId can only contain [a-zA-Z0-9.]");
+        }
         this.operations[operationId] = { ...definition, id: operationId };
+        ["input", "output"]
+            .filter(key => this.operations[operationId][key])
+            .forEach(key => {
+            if (!this.getApplication().hasSchema(this.operations[operationId][key])) {
+                delete this.operations[operationId][key];
+            }
+        });
     }
     /**
      * Register a request filtering
@@ -454,6 +536,13 @@ export class Core extends events.EventEmitter {
     registerCORSFilter(filter) {
         this._requestCORSFilters.push(filter);
     }
+    /**
+     * Register a new context provider
+     * @param provider
+     */
+    registerContextProvider(provider) {
+        this._contextProviders.unshift(provider);
+    }
     /**
      * Validate the object with schema
      *
@@ -461,10 +550,12 @@ export class Core extends events.EventEmitter {
      * @param object to validate
      */
     validateSchema(webdaObject, object, ignoreRequired) {
-        let name = typeof webdaObject === "string"
-            ? webdaObject
-            : this.application.getFullNameFromPrototype(Object.getPrototypeOf(webdaObject));
+        let name = typeof webdaObject === "string" ? webdaObject : this.application.getModelFromInstance(webdaObject);
         let cacheName = name;
+        if (name?.endsWith("?")) {
+            name = name.substring(0, name.length - 1);
+            ignoreRequired = true;
+        }
         if (ignoreRequired) {
             cacheName += "_noRequired";
         }
@@ -552,7 +643,6 @@ export class Core extends events.EventEmitter {
      * @param {String} name The service name to retrieve
      */
     getService(name = "") {
-        name = name.toLowerCase();
         return this.services[name];
     }
     /**
@@ -644,6 +734,21 @@ export class Core extends events.EventEmitter {
     getGlobalParams() {
         return this.configuration.parameters || {};
     }
+    /**
+     * Get the system context
+     * @returns
+     */
+    getGlobalContext() {
+        return this.globalContext;
+    }
+    /**
+     * Set the system context
+     * @param context
+     */
+    setGlobalContext(context) {
+        this.globalContext = context;
+        context.getSession().login("system", "system");
+    }
     /**
      * Reinit one service
      * @param service
@@ -671,7 +776,7 @@ export class Core extends events.EventEmitter {
         }
         if (JSON.stringify(Object.keys(configuration)) !== JSON.stringify(Object.keys(this.configuration.services))) {
             this.log("ERROR", "Configuration update cannot modify services");
-            throw new WebdaError("REINIT_SERVICE_INJECTION", "Configuration is not designed to add dynamically services");
+            throw new WebdaError.CodeError("REINIT_SERVICE_INJECTION", "Configuration is not designed to add dynamically services");
         }
         this.configuration.services = configuration;
         let inits = [];
@@ -712,12 +817,12 @@ export class Core extends events.EventEmitter {
         }
         try {
             this.log("TRACE", "Constructing service", service);
-            this.services[service.toLowerCase()] = new serviceConstructor(this, service, this.getServiceParams(service));
+            this.services[service] = new serviceConstructor(this, service, this.getServiceParams(service));
         }
         catch (err) {
             this.log("ERROR", "Cannot create service", service, err);
             // @ts-ignore
-            this.failedServices[service.toLowerCase()] = { _createException: err };
+            this.failedServices[service] = { _createException: err };
         }
     }
     /**
@@ -726,39 +831,39 @@ export class Core extends events.EventEmitter {
      */
     createServices(excludes = []) {
         const services = this.configuration.services;
+        // @ts-ignore
+        const beans = process.webdaBeans || {};
         this.log("DEBUG", "BEANS", beans);
         for (let i in beans) {
-            let name = beans[i].constructor.name;
+            let name = beans[i].name;
             if (!services[name]) {
                 services[name] = {};
             }
             // Force type to Bean
             services[name].type = `Beans/${name}`;
             // Register the type
-            this.application.addService(`Beans/${name}`, beans[i].constructor);
+            this.application.addService(`Beans/${name}`, beans[i]);
         }
         // Construct services
         for (let service in services) {
-            if (excludes.indexOf(service.toLowerCase()) >= 0) {
+            if (excludes.indexOf(service) >= 0) {
                 continue;
             }
             this.createService(services, service);
         }
-        this.autoConnectServices();
+        // Call resolve on all services
+        Object.keys(this.services)
+            .filter(s => !excludes.includes(s))
+            .forEach(s => {
+            try {
+                this.services[s].resolve();
+            }
+            catch (err) {
+                this.log("ERROR", err);
+            }
+        });
         this.emit("Webda.Create.Services", this.services);
     }
-    /**
-     * Return all methods that are setters (startsWith("set"))
-     * @param obj service get setter from
-     */
-    _getSetters(obj) {
-        let methods = [];
-        while ((obj = Reflect.getPrototypeOf(obj))) {
-            let keys = Reflect.ownKeys(obj).filter(k => k.toString().startsWith("set"));
-            keys.forEach(k => methods.push(k));
-        }
-        return methods;
-    }
     /**
      * A registry is a predefined store
      * @returns
@@ -773,33 +878,6 @@ export class Core extends events.EventEmitter {
     getCrypto() {
         return this.cryptoService;
     }
-    /**
-     * Auto connect services with setters
-     */
-    autoConnectServices() {
-        for (let service in this.services) {
-            this.log("TRACE", "Auto-connect", service);
-            try {
-                let serviceBean = this.services[service];
-                if (!serviceBean.resolve) {
-                    this.log("ERROR", `${service} seems to not extend Service`);
-                    continue;
-                }
-                serviceBean.resolve();
-                let setters = this._getSetters(serviceBean);
-                setters.forEach(setter => {
-                    let targetService = this.services[setter.substr(3).toLowerCase()];
-                    if (targetService) {
-                        this.log("TRACE", "Auto-connecting", serviceBean.getName(), targetService.getName());
-                        serviceBean[setter](targetService);
-                    }
-                });
-            }
-            catch (err) {
-                this.log("ERROR", err);
-            }
-        }
-    }
     jsonFilter(key, value) {
         if (key[0] === "_")
             return undefined;
@@ -813,7 +891,7 @@ export class Core extends events.EventEmitter {
         // Init the registry
         const autoRegistry = this.configuration.services["Registry"] === undefined;
         (_a = this.configuration.services)["Registry"] ?? (_a["Registry"] = {
-            type: "webda/memorystore",
+            type: "Webda/MemoryStore",
             persistence: {
                 path: ".registry",
                 key: machineIdSync()
@@ -823,7 +901,7 @@ export class Core extends events.EventEmitter {
         this.registry = this.getService("Registry").resolve();
         // Init the key service
         (_b = this.configuration.services)["CryptoService"] ?? (_b["CryptoService"] = {
-            type: "webda/cryptoservice",
+            type: "Webda/CryptoService",
             autoRotate: autoRegistry ? 30 : undefined,
             autoCreate: true
         });
@@ -831,12 +909,12 @@ export class Core extends events.EventEmitter {
         this.cryptoService = this.getService("CryptoService").resolve();
         // Session Manager
         (_c = this.configuration.services)["SessionManager"] ?? (_c["SessionManager"] = {
-            type: "webda/cookiesessionmanager"
+            type: "Webda/CookieSessionManager"
         });
         if (this.configuration.services !== undefined) {
-            let excludes = ["registry", "cryptoservice"];
+            let excludes = ["Registry", "CryptoService"];
             if (this.configuration.parameters.configurationService) {
-                excludes.push(this.configuration.parameters.configurationService.toLowerCase());
+                excludes.push(this.configuration.parameters.configurationService);
             }
             // Do not recreate the configuration services
             this.createServices(excludes);
@@ -845,6 +923,20 @@ export class Core extends events.EventEmitter {
         this._initiated = true;
         this.emit("Webda.Init", this.configuration);
     }
+    /**
+     * Get a context based on the info
+     * @param info
+     * @returns
+     */
+    async newContext(info, noInit = false) {
+        let context;
+        this._contextProviders.find(provider => (context = provider.getContext(info)) !== undefined);
+        if (!noInit) {
+            await context.init();
+        }
+        await this.emitSync("Webda.NewContext", { context, info });
+        return context;
+    }
     /**
      * Create a new context for a request
      *
@@ -853,13 +945,8 @@ export class Core extends events.EventEmitter {
      * @param stream - The request output stream if any
      * @return A new context object to pass along
      */
-    async newContext(httpContext, stream = undefined, noInit = false) {
-        let res = (new (this.getModel(this.parameter("contextModel") || "Webda/Context"))(this, httpContext, stream));
-        if (!noInit) {
-            await res.init();
-        }
-        await this.emitSync("Webda.NewContext", res);
-        return res;
+    async newWebContext(httpContext, stream = undefined, noInit = false) {
+        return await this.newContext({ http: httpContext, stream: stream });
     }
     /**
      * Convert an object to JSON using the Webda json filter
@@ -943,10 +1030,10 @@ export class Core extends events.EventEmitter {
      */
     async checkRequest(ctx) {
         // Do not need to filter on OPTIONS as CORS is for that
-        if (ctx.getHttpContext().getMethod() === "OPTIONS") {
+        if (ctx.getHttpContext().getMethod() === "OPTIONS" || this._requestFilters.length === 0) {
             return true;
         }
-        return (await Promise.all(this._requestFilters.map(filter => filter.checkRequest(ctx)))).some(v => v);
+        return (await Promise.all(this._requestFilters.map(filter => filter.checkRequest(ctx, "AUTH")))).some(v => v);
     }
     /**
      * Verify if an origin is allowed to do request on the API
@@ -954,8 +1041,13 @@ export class Core extends events.EventEmitter {
      * @param context Context of the request
      */
     async checkCORSRequest(ctx) {
-        return (await Promise.all(this._requestCORSFilters.map(filter => filter.checkRequest(ctx)))).some(v => v);
+        return (await Promise.all(this._requestCORSFilters.map(filter => filter.checkRequest(ctx, "CORS")))).some(v => v);
     }
+    /**
+     * Export OpenAPI
+     * @param skipHidden
+     * @returns
+     */
     exportOpenAPI(skipHidden = true) {
         var _a;
         let packageInfo = this.application.getPackageDescription();
@@ -1003,12 +1095,7 @@ export class Core extends events.EventEmitter {
             let desc = {
                 type: "object"
             };
-            let modelDescription = this.getModel(i);
             let modelName = model.name || i.split("/").pop();
-            // Only export CoreModel info
-            if (!this.application.extends(modelDescription, CoreModel)) {
-                continue;
-            }
             let schema = this.application.getSchema(i);
             if (schema) {
                 for (let j in schema.definitions) {