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

package/lib/application.d.ts

@@ -1,7 +1,199 @@
-import { CachedModule, Configuration, ConfigurationV1, Context, Core, CoreModelDefinition, Module, Service } from "./index";
-import { Deployment } from "./models/deployment";
+import { Context, Core, CoreModelDefinition, Service } from "./index";
 import { WorkerLogLevel, WorkerOutput } from "@webda/workout";
-import { JSONSchema6 } from "json-schema";
+import { JSONSchema7 } from "json-schema";
+import { OpenAPIV3 } from "openapi-types";
+export declare type PackageDescriptorAuthor = string | {
+    name?: string;
+    email?: string;
+    url?: string;
+};
+export declare type Modda = ServiceConstructor<Service>;
+/**
+ * Some package exists but seems pretty big for this
+ * https://classic.yarnpkg.com/en/docs/package-json
+ */
+export interface PackageDescriptor {
+    name?: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+    license?: string | {
+        name: string;
+    };
+    homepage?: string;
+    bugs?: string;
+    repository?: string;
+    author?: PackageDescriptorAuthor;
+    contributors?: string[] | PackageDescriptorAuthor[];
+    files?: string[];
+    main?: string;
+    bin?: string | {
+        [key: string]: string;
+    };
+    man?: string | string[];
+    directories?: {
+        [key: string]: string;
+    };
+    scripts?: {
+        [key: string]: string;
+    };
+    config?: any;
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
+        [key: string]: string;
+    };
+    peerDependencies?: {
+        [key: string]: string;
+    };
+    peerDependenciesMeta?: {
+        [key: string]: {
+            optional: boolean;
+        };
+    };
+    optionalDependencies?: {
+        [key: string]: string;
+    };
+    bundledDependencies?: string[];
+    flat?: boolean;
+    resolutions?: {
+        [key: string]: string;
+    };
+    engines?: {
+        [key: string]: string;
+    };
+    os?: string[];
+    cpu?: string[];
+    private?: boolean;
+    publishConfig?: any;
+    webda?: Partial<WebdaPackageDescriptor>;
+    termsOfService?: string;
+    title?: 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
+     */
+    moddas?: {
+        [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]: JSONSchema7;
+    };
+    /**
+     * Application beans
+     */
+    beans?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Cached module is all modules discover plus local package including the sources list
+ */
+export interface CachedModule extends Module {
+    /**
+     * Contained dynamic information on the project
+     * Statically capture on deployment
+     */
+    project: ProjectInformation;
+}
+export declare type UnpackedConfiguration = {
+    version: 3;
+    /**
+     * 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;
+        /**
+         * Define the model to use for Context
+         *
+         * @default Context
+         */
+        contextModel?: string;
+        /**
+         * Allow any other type of parameters
+         */
+        [key: string]: any;
+    };
+    /**
+     * OpenAPI override
+     */
+    openapi?: Partial<OpenAPIV3.Document>;
+};
+export declare type Configuration = UnpackedConfiguration & {
+    /**
+     * Cached modules to avoid scanning node_modules
+     * This is used by packagers
+     */
+    cachedModules?: CachedModule;
+};
+export declare type StoredConfiguration = Configuration;
 /**
  * Return the gather information from the repository
  * @mermaid Make TypeDoc easy to use with mermaid.js
@@ -56,29 +248,66 @@ export interface GitInformation {
  */
 export interface ServiceConstructor<T extends Service> {
     new (webda: Core, name: string, params: any): T;
-    getModda(): any;
-    getSchema(): JSONSchema6;
+}
+export declare enum SectionEnum {
+    Moddas = "moddas",
+    Deployers = "deployers",
+    Models = "models",
+    Beans = "beans"
 }
 /**
- * Retrieve a JSONSchema from a webda object
- *
+ * Webda specific metadata for the project
  */
-export interface SchemaResolver {
-    fromPrototype(type: any): JSONSchema6;
-    fromServiceType(type: string): JSONSchema6;
+export interface WebdaPackageDescriptor {
+    /**
+     * Webda namespace
+     */
+    namespace?: string;
+    /**
+     * Logo to display within the shell tty
+     */
+    logo?: string;
+    /**
+     * Information on the workspace
+     */
+    workspaces?: {
+        packages: string[];
+        parent: PackageDescriptor;
+        path: string;
+    };
+    [key: string]: any;
 }
 /**
- * Implement the default way of retrieving schema
+ * Information on the whole project
  */
-export declare class DefaultSchemaResolver implements SchemaResolver {
+export interface ProjectInformation {
+    /**
+     * package.json information
+     */
+    package: PackageDescriptor;
     /**
-     * Application
+     * Webda project information
+     *
+     * It is the aggregation of webda information contained in package
+     * and its workspace meta
+     */
+    webda: WebdaPackageDescriptor;
+    /**
+     * Git information gathered
+     */
+    git: GitInformation;
+    /**
+     * Deployment information
      */
-    protected app: Application;
-    constructor(app: Application);
-    fromServiceType(type?: string): JSONSchema6;
-    fromPrototype(type: any): JSONSchema6;
+    deployment: {
+        name: string;
+        [key: string]: any;
+    };
 }
+/**
+ * Type of Section
+ */
+export declare type Section = "moddas" | "deployers" | "models" | "beans";
 /**
  * Map a Webda Application
  *
@@ -96,7 +325,7 @@ export declare class Application {
     /**
      * Get Application root path
      */
-    protected appPath: string;
+    readonly appPath: string;
     /**
      * Base configuration loaded from webda.config.json
      */
@@ -105,10 +334,6 @@ export declare class Application {
      * Current deployment
      */
     protected currentDeployment: string;
-    /**
-     * Contains all definitions from imported modules and current code
-     */
-    protected cachedModules: CachedModule;
     /**
      * Contains definitions of current application
      */
@@ -124,10 +349,10 @@ export declare class Application {
         [key: string]: any;
     };
     /**
-     * Services type registry
+     * Moddas registry
      */
-    protected services: {
-        [key: string]: ServiceConstructor<Service>;
+    protected moddas: {
+        [key: string]: Modda;
     };
     /**
      * Models type registry
@@ -135,26 +360,10 @@ export declare class Application {
     protected models: {
         [key: string]: any;
     };
-    /**
-     * Flag if application has been compiled already
-     */
-    protected compiled: boolean;
     /**
      * Class Logger
      */
     protected logger: WorkerOutput;
-    /**
-     * Contains package.json of application
-     */
-    protected packageDescription: any;
-    /**
-     * Contains webda section of package.json and workspaces if exist
-     */
-    protected packageWebda: any;
-    /**
-     * Webda namespace
-     */
-    protected namespace: string;
     /**
      * Detect if running as workspace
      */
@@ -164,30 +373,47 @@ export declare class Application {
      */
     protected initTime: number;
     /**
-     * Current Schema resolver
+     * Configuration file
+     */
+    readonly configurationFile: string;
+    /**
+     * Current deployment file
+     */
+    deploymentFile: string;
+    /**
+     * Current application
      */
-    protected schemaResolver: SchemaResolver;
+    protected static active: Application;
     /**
      *
      * @param {string} fileOrFolder to load Webda Application from
      * @param {Logger} logger
      */
-    constructor(file: string, logger?: WorkerOutput, allowModule?: boolean);
+    constructor(file: string, logger?: WorkerOutput);
     /**
+     * Import all required modules
+     */
+    load(): Promise<this>;
+    /**
+     * Allow subclass to implement migration
      *
-     * @param proto Prototype to send
+     * @param file
+     * @returns
      */
-    getFullNameFromPrototype(proto: any): string;
+    loadConfiguration(file: string): void;
     /**
-     * Set the current schema resolver
      *
-     * @param resolver
+     * @param proto Prototype to send
      */
-    setSchemaResolver(resolver: SchemaResolver): void;
+    getFullNameFromPrototype(proto: any): string;
     /**
-     * Get schema resolver
+     * Get a schema from a type
+     *
+     * Schema should be precomputed in the default app
+     * @param type
+     * @returns
      */
-    getSchemaResolver(): SchemaResolver;
+    getSchema(type: string): JSONSchema7;
     /**
      * Check if application has cached modules
      *
@@ -196,40 +422,16 @@ export declare class Application {
      * take the schema from the cached modules also
      */
     isCached(): boolean;
-    /**
-     * Check package.json
-     */
-    loadPackageInfos(): void;
     /**
      * Retrieve specific webda conf from package.json
      *
      * In case of workspaces the object is combined
      */
-    getPackageWebda(): any;
+    getPackageWebda(): WebdaPackageDescriptor;
     /**
      * Retrieve content of package.json
      */
-    getPackageDescription(): any;
-    /**
-     * Set the status of the compilation
-     *
-     * @param compile true will avoid trigger new compilation
-     */
-    preventCompilation(compile: boolean): void;
-    /**
-     * Migrate from v0 to v1 configuration
-     *
-     * A V0 is a webda.config.json that does not contain any version tag
-     *
-     * @param config
-     */
-    migrateV0Config(config: any): Configuration;
-    /**
-     * Migrate from v1 to v2 configuration format
-     *
-     * @param config
-     */
-    migrateV1Config(config: ConfigurationV1): Configuration;
+    getPackageDescription(): PackageDescriptor;
     /**
      * Log information
      *
@@ -253,25 +455,38 @@ export declare class Application {
      * @param name
      * @param service
      */
-    addService(name: string, service: ServiceConstructor<Service>): void;
+    addService(name: string, service: Modda): this;
+    /**
+     *
+     * @param section
+     * @param name
+     * @returns
+     */
+    getWebdaObject(section: Section, name: any): any;
     /**
      * Get a service based on name
      *
      * @param name
      */
-    getService(name: any): ServiceConstructor<Service<import("./index").ServiceParameters>>;
+    getModda(name: any): Modda;
     /**
      * Return all services of the application
      */
-    getServices(): {
-        [key: string]: ServiceConstructor<Service<import("./index").ServiceParameters>>;
+    getModdas(): {
+        [key: string]: Modda;
+    };
+    /**
+     * Return all beans of the application
+     */
+    getBeans(): {
+        [key: string]: string;
     };
     /**
      * Retrieve the model implementation
      *
      * @param name model to retrieve
      */
-    getModel(name: string): any;
+    getModel(name: string): Context | CoreModelDefinition;
     /**
      * Get all models definitions
      */
@@ -282,7 +497,7 @@ export declare class Application {
      * Return all deployers
      */
     getDeployers(): {
-        [key: string]: ServiceConstructor<Service>;
+        [key: string]: Modda;
     };
     /**
      * Add a new model
@@ -290,22 +505,14 @@ export declare class Application {
      * @param name
      * @param model
      */
-    addModel(name: string, model: any): void;
+    addModel(name: string, model: any): this;
     /**
      * Add a new deployer
      *
      * @param name
      * @param model
      */
-    addDeployer(name: string, model: any): void;
-    /**
-     * 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: string): boolean;
+    addDeployer(name: string, model: any): this;
     /**
      * Return webda current version
      *
@@ -313,14 +520,13 @@ export declare class Application {
      * @since 0.4.0
      */
     getWebdaVersion(): string;
-    getDeployment(deploymentName?: string): Deployment;
     /**
      * Retrieve Git Repository information
      *
      * {@link GitInformation} for more details on how the information is gathered
      * @return the git information
      */
-    getGitInformation(): GitInformation;
+    getGitInformation(_packageName?: string, _version?: string): GitInformation;
     /**
      * Allow variable inside of string
      *
@@ -366,67 +572,21 @@ export declare class Application {
      */
     replaceVariables(object: any, replacements?: any): any;
     /**
-     * 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(): string;
+    /**
+     * Return all application modules merged as one
      *
-     * @param deploymentName to use for the Configuration
+     * Used when deployed
+     * @returns
+     */
+    getModules(): CachedModule;
+    /**
+     * Get application configuration
+     * @returns
      */
-    getConfiguration(deploymentName?: string): Configuration;
+    getConfiguration(_deployment?: string): Configuration;
     /**
      * Return current Configuration of the Application
      *
@@ -437,35 +597,6 @@ export declare class Application {
      * ```
      */
     getCurrentConfiguration(): Configuration;
-    /**
-     * 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: string): void;
-    /**
-     * Get current deployment name
-     */
-    getCurrentDeployment(): string;
-    /**
-     * Compile the application if it is a Typescript application
-     * Do nothing otherwise
-     */
-    compile(): void;
-    /**
-     * Load all imported modules and current module
-     * It will compile module
-     * Generate the current module file
-     * Load any imported webda.module.json
-     */
-    loadModules(): void;
-    getModules(): CachedModule;
-    /**
-     * Generate the module for current application
-     */
-    generateModule(): void;
     /**
      * Import a file
      *
@@ -473,18 +604,18 @@ export declare class Application {
      *
      * @param info
      */
-    resolveRequire(info: string): any;
+    importFile(info: string): Promise<any>;
     /**
      * Load local module
      */
-    loadLocalModule(): void;
+    loadLocalModule(): Promise<void>;
     /**
      * Load the module,
      *
      * @protected
      * @ignore Useless for documentation
      */
-    loadModule(info: Module, parent?: string): void;
+    loadModule(module: Module, parent?: string): Promise<void>;
     /**
      * Return the full name including namespace
      *
@@ -502,13 +633,4 @@ export declare class Application {
      * @param className
      */
     extends(obj: any, className: any): boolean;
-    /**
-     * Load a javascript file and check for Modda
-     * @param path to load
-     */
-    protected loadJavascriptFile(absolutePath: string): void;
-    /**
-     * Get the application files
-     */
-    getPackagesLocations(): string[];
 }