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

package/lib/core.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
+import { WorkerLogLevel, WorkerOutput } from "@webda/workout";
+import Ajv from "ajv";
 import * as events from "events";
-import { JSONSchema6 } from "json-schema";
 import { OpenAPIV3 } from "openapi-types";
 import * as vm from "vm";
-import { Application } from "./application";
+import { Application, Configuration } from "./application";
 import { Context, HttpContext, Logger, Service } from "./index";
 import { CoreModel, CoreModelDefinition } from "./models/coremodel";
-import { RouteInfo, Router } from "./router";
-import { WorkerOutput, WorkerLogLevel } from "@webda/workout";
-import { AbstractDeployer } from "./utils/abstractdeployer";
+import { OpenAPIWebdaDefinition, RouteInfo, Router } from "./router";
 /**
  * Error with a code
  */
@@ -31,190 +30,6 @@ export declare class WebdaError extends Error {
 export interface EventWithContext {
     context: Context;
 }
-/**
- * Emitted when new request comes in
- */
-export interface EventWebdaRequest extends EventWithContext {
-}
-/**
- * Emitted when new result is sent
- */
-export interface EventWebdaResult extends EventWithContext {
-}
-/**
- * Emitted when a request does not match any route
- */
-export interface EventWebda404 extends EventWithContext {
-}
-/**
- * Define a reusable service
- *
- * A Modda is a class that can be reused
- * For example:
- *  - MongoDB Store implementation
- *  - SQS Service implementation
- *  - etc
- */
-export interface ModdaDefinition {
-    uuid: string;
-    /**
-     * Label of the service
-     */
-    label: string;
-    /**
-     * Description of your service
-     */
-    description: string;
-    /**
-     * Documentation page must be available online
-     */
-    documentation?: string;
-    /**
-     * Type of services
-     */
-    category?: "services" | "models" | "deployers";
-    /**
-     * URL of the logo to display
-     */
-    logo?: string;
-}
-/**
- * A Webda module is a NPM package
- *
- * It contains one or more Modda to provide features
- */
-export interface Module {
-    /**
-     * Services provided by the module
-     */
-    services?: {
-        [key: string]: string;
-    };
-    /**
-     * Models provided by the module
-     */
-    models?: {
-        [key: string]: string;
-    };
-    /**
-     * Deployers provided by the module
-     *
-     * @link Deployer
-     */
-    deployers?: {
-        [key: string]: string;
-    };
-    /**
-     * Schemas for services, deployers and coremodel
-     */
-    schemas?: {
-        [key: string]: JSONSchema6;
-    };
-}
-/**
- * Cached module is all modules discover plus local package including the sources list
- */
-export interface CachedModule extends Module {
-    /**
-     * Source files to import
-     */
-    sources?: string[];
-}
-/**
- * Configuration from Webda 1.0 > version > 0.5
- */
-export interface ConfigurationV1 {
-    /**
-     * Configuration version
-     */
-    version: number;
-    /**
-     * Cached modules to avoid scanning node_modules
-     * This is used by packagers
-     */
-    cachedModules?: CachedModule;
-    /**
-     * Models
-     */
-    models?: any;
-    /**
-     * Services configuration
-     */
-    services?: any;
-    [key: string]: any;
-}
-/**
- * Configuration from Webda version >= 1.0
- */
-export interface Configuration {
-    /**
-     * @minimum 2
-     */
-    version: number;
-    /**
-     * Cached modules to avoid scanning node_modules
-     * This is used by packagers
-     */
-    cachedModules?: CachedModule;
-    /**
-     * Module definition
-     */
-    module: Module;
-    /**
-     * Services configuration
-     */
-    services?: any;
-    /**
-     * Global parameters
-     */
-    parameters?: {
-        /**
-         * Allowed origin for referer that match
-         * any of this regexp
-         *
-         * {@link OriginFilter}
-         */
-        csrfOrigins?: string[];
-        /**
-         * Allow you to authorize one or several websites
-         * If you use "*" then the API is open to direct call and any origins
-         *
-         * {@link WebsiteOriginFilter}
-         */
-        website?: string | string[] | {
-            url: string;
-        };
-        /**
-         * Cookie configuration for session
-         */
-        cookie?: {
-            sameSite: "None" | "Strict" | "Lax";
-            domain: string;
-            /**
-             * @minimum 1
-             */
-            maxAge: number;
-            path: string;
-        };
-        /**
-         * Read from the configuration service before init
-         */
-        configurationService?: string;
-        /**
-         * Application salt
-         */
-        salt?: string;
-        /**
-         * Define the api url
-         */
-        apiUrl?: string;
-        [key: string]: any;
-    };
-    /**
-     * OpenAPI override
-     */
-    openapi?: any;
-}
 /**
  * RequestFilter allow a service which implement it to control incoming request
  *
@@ -252,14 +67,51 @@ export declare class WebsiteOriginFilter implements RequestFilter<Context> {
     checkRequest(context: Context): Promise<boolean>;
 }
 export declare function Bean(constructor: Function): void;
-export declare function Route(route: string, methods?: string | string[], allowPath?: boolean, openapi?: any): (target: any, executor: string, descriptor: PropertyDescriptor) => void;
+export declare function Route(route: string, methods?: string | string[], allowPath?: boolean, openapi?: OpenAPIWebdaDefinition): (target: any, executor: string) => void;
+export declare type CoreEvents = {
+    /**
+     * Emitted when new result is sent
+     */
+    "Webda.Result": EventWithContext;
+    /**
+     * Emitted when new request comes in
+     */
+    "Webda.Request": EventWithContext;
+    /**
+     * Emitted when a request does not match any route
+     */
+    "Webda.404": EventWithContext;
+    /**
+     * Emitted when Services have been initialized
+     */
+    "Webda.Init.Services": {
+        [key: string]: Service;
+    };
+    /**
+     * Emitted when Services have been created
+     */
+    "Webda.Create.Services": {
+        [key: string]: Service;
+    };
+    /**
+     * Emitted when Core is initialized
+     */
+    "Webda.Init": Configuration;
+    /**
+     * Emitted whenever a new Context is created
+     */
+    "Webda.NewContext": Context;
+    [key: string]: unknown;
+};
+declare type NoSchemaResult = null;
+declare type SchemaValidResult = true;
 /**
  * This is the main class of the framework, it handles the routing, the services initialization and resolution
  *
  * @class Core
  * @category CoreFeatures
  */
-export declare class Core extends events.EventEmitter {
+export declare class Core<E extends CoreEvents = CoreEvents> extends events.EventEmitter {
     /**
      * Webda Services
      * @hidden
@@ -267,9 +119,21 @@ export declare class Core extends events.EventEmitter {
     protected services: {
         [key: string]: Service;
     };
+    /**
+     * Application that generates this Core
+     */
     protected application: Application;
+    /**
+     * Router that will route http request in
+     */
     protected router: Router;
+    /**
+     * If Core is already initiated
+     */
     protected _initiated: boolean;
+    /**
+     * Services who failed to create or initialize
+     */
     protected failedServices: {
         [key: string]: any;
     };
@@ -286,17 +150,26 @@ export declare class Core extends events.EventEmitter {
     /**
      * JSON Schema validator instance
      */
-    protected _ajv: any;
+    protected _ajv: Ajv;
     /**
      * JSON Schema registry
+     * Save if a schema was added to Ajv already
      */
-    protected _ajvSchemas: any;
+    protected _ajvSchemas: {
+        [key: string]: true;
+    };
     /**
      * Current executor
      */
     protected _currentExecutor: any;
     protected _configFile: string;
+    /**
+     * Contains the current initialization process
+     */
     protected _initPromise: Promise<void>;
+    /**
+     * When the Core was initialized
+     */
     protected _initTime: number;
     /**
      * Console logger
@@ -304,17 +177,39 @@ export declare class Core extends events.EventEmitter {
      */
     protected logger: Logger;
     /**
-     * CORS Filter registry
+     * Request Filter registry
      *
      * Added via [[Webda.registerRequestFilter]]
      * See [[CorsFilter]]
      */
     protected _requestFilters: RequestFilter<Context>[];
+    /**
+     * CORS Filter registry
+     *
+     * Added via [[Webda.registerCORSRequestFilter]]
+     * See [[CorsFilter]]
+     */
+    protected _requestCORSFilters: RequestFilter<Context>[];
+    /**
+     * Worker output
+     *
+     * @see @webda/workout
+     */
     private workerOutput;
+    /**
+     * Store the instance id
+     */
+    private instanceId;
     /**
      * @params {Object} config - The configuration Object, if undefined will load the configuration file
      */
     constructor(application: Application);
+    /**
+     * Return Core instance id
+     *
+     * It is a random generated string
+     */
+    getInstanceId(): string;
     /**
      * Get absolute url with subpath
      * @param subpath
@@ -336,13 +231,7 @@ export declare class Core extends events.EventEmitter {
     /**
      * Retrieve all detected modules definition
      */
-    getModules(): CachedModule;
-    /**
-     * Retrieve all deployers
-     */
-    getDeployers(): {
-        [key: string]: import("./application").ServiceConstructor<Service<import("./index").ServiceParameters>>;
-    };
+    getModules(): import("./application").CachedModule;
     /**
      * Return application definition
      */
@@ -356,13 +245,32 @@ export declare class Core extends events.EventEmitter {
      * @param service
      */
     protected initService(service: string): Promise<void>;
+    /**
+     * Get an object from the application based on its full uuid
+     * @param fullUuid
+     * @param partials
+     */
+    getModelObject<T extends CoreModel = CoreModel>(fullUuid: string, partials?: any): Promise<T>;
     /**
      * Init Webda
      *
      * It will resolve Services init method and autolink
      */
     init(): Promise<void>;
+    /**
+     * Register a request filtering
+     *
+     * Will apply to all requests regardless of the devMode
+     * @param filter
+     */
     registerRequestFilter(filter: RequestFilter<Context>): void;
+    /**
+     * Register a CORS request filtering
+     *
+     * Does not apply in devMode
+     * @param filter
+     */
+    registerCORSFilter(filter: RequestFilter<Context>): void;
     /**
      *
      * @param {Object} executor The executor to expose as executor
@@ -375,11 +283,7 @@ export declare class Core extends events.EventEmitter {
      * @param schema path to use
      * @param object to validate
      */
-    validateSchema(webdaObject: CoreModel | Service | AbstractDeployer, object: any): any;
-    /**
-     * Get last errors from AJV schema validator ( called through validate method )
-     */
-    validationLastErrors(): any;
+    validateSchema(webdaObject: CoreModel | string, object: any): NoSchemaResult | SchemaValidResult;
     /**
      * Return webda current version
      *
@@ -433,7 +337,7 @@ export declare class Core extends events.EventEmitter {
      * @param type The type of implementation
      * @returns {{}}
      */
-    getServicesImplementations(type?: any): {
+    getServicesOfType(type?: any): {
         [key: string]: Service;
     };
     getConfiguration(): Configuration;
@@ -451,10 +355,6 @@ export declare class Core extends events.EventEmitter {
     getModels(): {
         [key: string]: CoreModelDefinition;
     };
-    /**
-     * Register model
-     */
-    registerModel(name: string, clazz: any): void;
     /**
      * Check for a model name and return the wanted class or throw exception if none found
      *
@@ -471,6 +371,12 @@ export declare class Core extends events.EventEmitter {
      * @returns {String} Current secret
      */
     getSecret(): string;
+    /**
+     * Retrieve a HMAC for a string
+     * @param data
+     * @returns
+     */
+    getHmac(data: string): Promise<string>;
     /**
      * Return a salt to use when doing digest
      *
@@ -488,11 +394,11 @@ export declare class Core extends events.EventEmitter {
      *
      * @abstract
      */
-    flushHeaders(context: Context): void;
+    flushHeaders(_context: Context): void;
     /**
      * Flush the entire response to the client
      */
-    flush(context: Context): void;
+    flush(_context: Context): void;
     /**
      * Return if Webda is in debug mode
      */
@@ -539,6 +445,9 @@ export declare class Core extends events.EventEmitter {
      */
     protected autoConnectServices(): void;
     protected jsonFilter(key: string, value: any): any;
+    /**
+     * Init services and Beans along with Routes
+     */
     initStatics(): void;
     /**
      * Init Routes declare by @Route annotation
@@ -561,10 +470,29 @@ export declare class Core extends events.EventEmitter {
      * @return {String} The export of the strip object ( removed all attribute with _ )
      */
     toPublicJSON(object: any): string;
+    /**
+     * Return a UUID
+     *
+     * @param format to return different type of format
+     * Plan to implement base64 and maybe base85
+     */
+    getUuid(format?: "ascii" | "base64" | "hex" | "binary" | "uuid"): string;
+    /**
+     * @override
+     */
+    emit<K extends keyof E>(eventType: K | symbol | string, event?: E[K], ...data: any[]): boolean;
     /**
      * Emit the event with data and wait for Promise to finish if listener returned a Promise
      */
-    emitSync<T = any>(eventType: string, event?: T, ...data: any[]): Promise<any[]>;
+    emitSync<K extends keyof E>(eventType: K | symbol, event?: E[K], ...data: any[]): Promise<any[]>;
+    /**
+     * Type the listener part
+     * @param event
+     * @param listener
+     * @param queue
+     * @returns
+     */
+    on<Key extends keyof E>(event: Key | symbol, listener: (evt: E[Key]) => void): this;
     /**
      * Logs
      * @param level
@@ -576,10 +504,17 @@ export declare class Core extends events.EventEmitter {
      */
     parameter(name: string): any;
     /**
-     * Verify if an origin is allowed to do request on the API
+     * Verify if a request can be done
      *
      * @param context Context of the request
      */
     protected checkRequest(ctx: Context): Promise<boolean>;
+    /**
+     * Verify if an origin is allowed to do request on the API
+     *
+     * @param context Context of the request
+     */
+    protected checkCORSRequest(ctx: Context): Promise<boolean>;
     exportOpenAPI(skipHidden?: boolean): OpenAPIV3.Document;
 }
+export {};