@wocker/core 1.1.0-beta.0 → 1.1.0-beta.2

package/lib/modules/project/makes/ProjectConfig.d.ts

@@ -0,0 +1,61 @@
+import { FileSystem } from "../../../makes";
+import { EnvConfig, ProjectType } from "../../../types";
+import { ServiceProperties } from "../types";
+export declare abstract class ProjectConfig {
+    type?: ProjectType;
+    image?: string;
+    dockerfile?: string;
+    composefile?: string;
+    preset?: string;
+    presetMode?: "global" | "project";
+    scripts: {
+        [script: string]: string;
+    };
+    cmd?: string[];
+    buildArgs: EnvConfig;
+    env: EnvConfig;
+    metadata: EnvConfig;
+    ports: string[];
+    volumes: string[];
+    extraHosts: EnvConfig;
+    services: Record<string, ServiceProperties>;
+    constructor(data: ProjectConfig.Data);
+    unsetBuildArg(name: string, service?: string): void;
+    getEnv(key: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
+    hasEnv(key: string): boolean;
+    setEnv(key: string, value: string | boolean, service?: string): void;
+    unsetEnv(key: string, service?: string): void;
+    abstract save(): void;
+    getVolumeBySource(source: string): string | undefined;
+    getVolumeByDestination(destination: string): string | undefined;
+    volumeMount(...volumes: string[]): void;
+    volumeUnmount(...volumes: string[]): void;
+    addExtraHost(host: string, domain: string): void;
+    removeExtraHost(host: string): void;
+    toObject(): ProjectConfig.Data;
+    static make(fs: FileSystem, filename: string): ProjectConfig;
+}
+export declare namespace ProjectConfig {
+    type Data = {
+        type?: ProjectType;
+        image?: string;
+        /** @deprecated */
+        imageName?: string;
+        dockerfile?: string;
+        composefile?: string;
+        preset?: string;
+        presetMode?: "global" | "project";
+        scripts?: {
+            [script: string]: string;
+        };
+        cmd?: string[];
+        buildArgs?: EnvConfig;
+        env?: EnvConfig;
+        metadata?: EnvConfig;
+        volumes?: string[];
+        ports?: string[];
+        extraHosts?: EnvConfig;
+        services?: Record<string, ServiceProperties>;
+    };
+}

package/lib/modules/project/makes/ProjectConfig.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectConfig = void 0;
+const volumeParse_1 = require("../../../utils/volumeParse");
+class ProjectConfig {
+    constructor(data) {
+        const { type, imageName, image = imageName, dockerfile, composefile, preset, presetMode, scripts = {}, cmd, buildArgs = {}, env = {}, metadata = {}, volumes = [], ports = [], extraHosts = {}, services = {} } = data;
+        this.type = type;
+        this.image = image;
+        this.dockerfile = dockerfile;
+        this.composefile = composefile;
+        this.preset = preset;
+        this.presetMode = presetMode;
+        this.scripts = scripts;
+        this.cmd = cmd;
+        this.buildArgs = buildArgs;
+        this.env = env;
+        this.metadata = metadata;
+        this.volumes = volumes;
+        this.ports = ports;
+        this.extraHosts = extraHosts;
+        this.services = services;
+    }
+    unsetBuildArg(name, service) {
+        if (service) {
+            if (!this.services[service]) {
+                return;
+            }
+            if (this.services[service].buildArgs && name in this.services[service].buildArgs) {
+                delete this.services[service].buildArgs[name];
+            }
+            return;
+        }
+        if (name in this.buildArgs) {
+            delete this.buildArgs[name];
+        }
+    }
+    getEnv(key, byDefault) {
+        if (key in this.env) {
+            return this.env[key];
+        }
+        return byDefault;
+    }
+    hasEnv(key) {
+        return this.env.hasOwnProperty(key);
+    }
+    setEnv(key, value, service) {
+        const sValue = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
+        if (service) {
+            if (!this.services[service]) {
+                return;
+            }
+            if (!this.services[service].env) {
+                this.services[service].env = {};
+            }
+            this.services[service].env[key] = sValue;
+            return;
+        }
+        this.env[key] = sValue;
+    }
+    unsetEnv(key, service) {
+        if (service) {
+            if (!this.services[service]) {
+                throw new Error(`Service "${service}" not found`);
+            }
+            if (this.services[service].env && key in this.services[service].env) {
+                delete this.services[service].env[key];
+                if (Object.keys(this.services[service].env).length === 0) {
+                    delete this.services[service].env;
+                }
+            }
+            return;
+        }
+        if (key in this.env) {
+            delete this.env[key];
+        }
+    }
+    getVolumeBySource(source) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
+        });
+    }
+    volumeMount(...volumes) {
+        if (volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const { destination } = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = [
+            ...(this.volumes || []).filter((v) => {
+                return v !== this.getVolumeByDestination(destination);
+            }),
+            volume
+        ];
+        this.volumeMount(...restVolumes);
+    }
+    volumeUnmount(...volumes) {
+        if (!this.volumes || volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const v = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = this.volumes.filter((mounted) => {
+            const m = (0, volumeParse_1.volumeParse)(mounted);
+            return v.source !== m.source && v.destination !== m.destination;
+        });
+        if (this.volumes.length === 0) {
+            return;
+        }
+        this.volumeUnmount(...restVolumes);
+    }
+    addExtraHost(host, domain) {
+        this.extraHosts[host] = domain;
+    }
+    removeExtraHost(host) {
+        if (host in this.extraHosts) {
+            delete this.extraHosts[host];
+        }
+    }
+    toObject() {
+        return {
+            type: this.type,
+            image: this.image,
+            dockerfile: this.dockerfile,
+            composefile: this.composefile,
+            preset: this.preset,
+            presetMode: this.presetMode,
+            scripts: Object.keys(this.scripts).length > 0 ? this.scripts : undefined,
+            cmd: this.cmd,
+            buildArgs: Object.keys(this.buildArgs).length > 0 ? this.buildArgs : undefined,
+            env: Object.keys(this.env).length > 0 ? this.env : undefined,
+            metadata: Object.keys(this.metadata).length > 0 ? this.metadata : undefined,
+            volumes: this.volumes.length > 0 ? this.volumes : undefined,
+            ports: this.ports.length > 0 ? this.ports : undefined,
+        };
+    }
+    static make(fs, filename) {
+        let data = {};
+        if (fs.exists(filename)) {
+            data = fs.readJSON(filename);
+        }
+        return new class extends ProjectConfig {
+            constructor(data) {
+                super(data);
+            }
+            save() {
+                if (!fs.exists()) {
+                    fs.mkdir("", {
+                        recursive: true
+                    });
+                }
+                fs.writeJSON(filename, this.toObject());
+            }
+        }(data);
+    }
+}
+exports.ProjectConfig = ProjectConfig;

package/lib/modules/project/makes/ServiceConfig.d.ts

@@ -0,0 +1,2 @@
+export declare class ServiceConfig {
+}

package/lib/modules/project/makes/ServiceConfig.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceConfig = void 0;
+class ServiceConfig {
+}
+exports.ServiceConfig = ServiceConfig;

package/lib/modules/project/repositories/ProjectRepository.d.ts

@@ -1,9 +1,18 @@
 import { Project } from "../makes/Project";
-export declare abstract class ProjectRepository {
-    abstract getByName(name: string): Project;
-    abstract save(project: Project): void;
-    abstract search(params: ProjectRepository.SearchParams): Project[];
-    abstract searchOne(params: ProjectRepository.SearchParams): Project;
+import { ProjectConfig } from "../makes/ProjectConfig";
+import { AppFileSystemService, AppService } from "../../../services";
+import { FileSystemDriver } from "../../../types";
+import { ProjectConfigScope } from "../types";
+export declare class ProjectRepository {
+    protected readonly appService: AppService;
+    protected readonly fs: AppFileSystemService;
+    protected readonly driver: FileSystemDriver;
+    constructor(appService: AppService, fs: AppFileSystemService, driver: FileSystemDriver);
+    getConfig(name: string, scope: ProjectConfigScope): ProjectConfig;
+    getByName(name: string): Project;
+    save(project: Project): void;
+    search(params: ProjectRepository.SearchParams): Project[];
+    searchOne(params: ProjectRepository.SearchParams): Project | null;
 }
 export declare namespace ProjectRepository {
     type SearchParams = Partial<{

package/lib/modules/project/repositories/ProjectRepository.js

@@ -5,12 +5,72 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectRepository = void 0;
 const decorators_1 = require("../../../decorators");
+const Project_1 = require("../makes/Project");
+const ProjectConfig_1 = require("../makes/ProjectConfig");
+const FileSystem_1 = require("../../../makes/FileSystem");
+const services_1 = require("../../../services");
+const env_1 = require("../../../env");
+const types_1 = require("../types");
 let ProjectRepository = class ProjectRepository {
+    constructor(appService, fs, driver) {
+        this.appService = appService;
+        this.fs = fs;
+        this.driver = driver;
+    }
+    getConfig(name, scope) {
+        const ref = this.appService.getProject(name);
+        if (!ref) {
+            throw new Error("");
+        }
+        switch (scope) {
+            case types_1.ProjectConfigScope.APP:
+                return ProjectConfig_1.ProjectConfig.make(this.fs.cd(`projects/${ref.name}`), "config.json");
+            case types_1.ProjectConfigScopeEnum.LOCAL:
+                return ProjectConfig_1.ProjectConfig.make(new FileSystem_1.FileSystem(ref.path, this.driver), "wocker.config.json");
+        }
+    }
+    getByName(name) {
+        const ref = this.appService.getProject(name);
+        if (!ref) {
+            throw new Error(`Project "${name}" not found`);
+        }
+        return new Project_1.Project(ref.name, ref.path);
+    }
+    save(project) {
+        project.save();
+    }
+    search(params) {
+        const { name, path } = params, projects = [];
+        for (const ref of this.appService.projects) {
+            if (name && ref.name !== name) {
+                continue;
+            }
+            if (path && ref.path !== path) {
+                continue;
+            }
+            const project = this.getByName(ref.name);
+            projects.push(project);
+        }
+        return projects;
+    }
+    searchOne(params) {
+        const [project] = this.search(params);
+        return project || null;
+    }
 };
 exports.ProjectRepository = ProjectRepository;
 exports.ProjectRepository = ProjectRepository = __decorate([
-    (0, decorators_1.Injectable)("PROJECT_REPOSITORY")
+    (0, decorators_1.Injectable)("PROJECT_REPOSITORY"),
+    __param(2, (0, decorators_1.Inject)(env_1.FILE_SYSTEM_DRIVER_KEY)),
+    __metadata("design:paramtypes", [services_1.AppService,
+        services_1.AppFileSystemService, Object])
 ], ProjectRepository);

package/lib/modules/project/types/ProjectConfigScope.d.ts

@@ -0,0 +1,9 @@
+import { ProjectRef } from "../../../types";
+export declare enum ProjectConfigScopeEnum {
+    APP = "app",
+    LOCAL = "project"
+}
+export type ProjectConfigScope = ProjectConfigScopeEnum;
+export declare const ProjectConfigScope: typeof ProjectConfigScopeEnum & {
+    fileName(scope: ProjectConfigScopeEnum, projectRef: ProjectRef): string;
+};

package/lib/modules/project/types/ProjectConfigScope.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectConfigScope = exports.ProjectConfigScopeEnum = void 0;
+var ProjectConfigScopeEnum;
+(function (ProjectConfigScopeEnum) {
+    ProjectConfigScopeEnum["APP"] = "app";
+    ProjectConfigScopeEnum["LOCAL"] = "project";
+})(ProjectConfigScopeEnum || (exports.ProjectConfigScopeEnum = ProjectConfigScopeEnum = {}));
+exports.ProjectConfigScope = Object.assign({}, ProjectConfigScopeEnum, {
+    fileName(scope, projectRef) {
+        switch (scope) {
+            case ProjectConfigScopeEnum.APP:
+                return `projects/${projectRef.name}/config.json`;
+            case ProjectConfigScopeEnum.LOCAL:
+                return `wocker.config.json`;
+            default:
+                throw new Error(`Unknown config scope: ${scope}`);
+        }
+    }
+});

package/lib/modules/project/types/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./ProjectConfigScope";
 export * from "./ProjectV1";
 export * from "./ServiceProperties";

package/lib/modules/project/types/index.js

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ProjectConfigScope"), exports);
 __exportStar(require("./ProjectV1"), exports);
 __exportStar(require("./ServiceProperties"), exports);

package/lib/services/AppFileSystemService.js

@@ -23,7 +23,7 @@ let AppFileSystemService = class AppFileSystemService extends FileSystem_1.FileS
 };
 exports.AppFileSystemService = AppFileSystemService;
 exports.AppFileSystemService = AppFileSystemService = __decorate([
-    (0, decorators_1.Injectable)(),
+    (0, decorators_1.Injectable)("APP_FILE_SYSTEM_SERVICE"),
     __param(0, (0, decorators_1.Inject)(env_1.WOCKER_DATA_DIR_KEY)),
     __param(1, (0, decorators_1.Inject)(env_1.FILE_SYSTEM_DRIVER_KEY)),
     __metadata("design:paramtypes", [String, Object])

package/lib/services/AppService.d.ts

@@ -1,17 +1,19 @@
 import { AppConfig } from "../makes/AppConfig";
 import { AppFileSystemService } from "./AppFileSystemService";
 import { ProcessService } from "./ProcessService";
+import { LogService } from "./LogService";
 import { ProjectRef, PluginRef, PresetRef, PresetSource } from "../types";
 type TypeMap = {
     [type: string]: string;
 };
 export declare class AppService {
     readonly version: string;
-    protected readonly processService: ProcessService;
     readonly fs: AppFileSystemService;
+    protected readonly processService: ProcessService;
+    protected readonly logService: LogService;
     protected _config?: AppConfig;
     protected readonly mapTypes: TypeMap;
-    constructor(version: string, processService: ProcessService, fs: AppFileSystemService);
+    constructor(version: string, fs: AppFileSystemService, processService: ProcessService, logService: LogService);
     get config(): AppConfig;
     get debug(): boolean;
     set debug(debug: boolean);
@@ -21,6 +23,7 @@ export declare class AppService {
     isVersionGT(version: string): boolean;
     isVersionGTE(version: string): boolean;
     getProjectTypes(): TypeMap;
+    getProject(name: string): ProjectRef | undefined;
     addProject(name: string, path: string): void;
     removeProject(name: string): void;
     addPlugin(name: string, env?: PluginRef["env"]): void;

package/lib/services/AppService.js

@@ -18,13 +18,15 @@ const Version_1 = require("../makes/Version");
 const AppConfig_1 = require("../makes/AppConfig");
 const AppFileSystemService_1 = require("./AppFileSystemService");
 const ProcessService_1 = require("./ProcessService");
+const LogService_1 = require("./LogService");
 const types_1 = require("../types");
 const env_1 = require("../env");
 let AppService = class AppService {
-    constructor(version, processService, fs) {
+    constructor(version, fs, processService, logService) {
         this.version = version;
-        this.processService = processService;
         this.fs = fs;
+        this.processService = processService;
+        this.logService = logService;
         this.mapTypes = {
             [types_1.ProjectType.IMAGE]: "Image",
             [types_1.ProjectType.PRESET]: "Preset",
@@ -64,6 +66,9 @@ let AppService = class AppService {
         }
         return this.mapTypes;
     }
+    getProject(name) {
+        return this.config.getProject(name);
+    }
     addProject(name, path) {
         this.config.addProject(name, path);
         this.config.save();
@@ -128,6 +133,7 @@ exports.AppService = AppService;
 exports.AppService = AppService = __decorate([
     (0, decorators_1.Injectable)("APP_SERVICE"),
     __param(0, (0, decorators_1.Inject)(env_1.WOCKER_VERSION_KEY)),
-    __metadata("design:paramtypes", [String, ProcessService_1.ProcessService,
-        AppFileSystemService_1.AppFileSystemService])
+    __metadata("design:paramtypes", [String, AppFileSystemService_1.AppFileSystemService,
+        ProcessService_1.ProcessService,
+        LogService_1.LogService])
 ], AppService);

package/lib/services/LogService.d.ts

@@ -1,11 +1,13 @@
-import { AppService } from "./AppService";
+import { ProcessService } from "./ProcessService";
 import { AppFileSystemService } from "./AppFileSystemService";
+import { LogLevel } from "../types";
 export declare class LogService {
-    protected readonly appService: AppService;
+    protected readonly processService: ProcessService;
     protected readonly fs: AppFileSystemService;
-    constructor(appService: AppService, fs: AppFileSystemService);
+    constructor(processService: ProcessService, fs: AppFileSystemService);
+    get logLevel(): LogLevel;
     protected get logName(): string;
-    protected _log(type: string, ...data: any[]): void;
+    protected _log(type: LogLevel, ...data: any[]): void;
     debug(...data: any[]): void;
     log(...data: any[]): void;
     info(...data: any[]): void;

package/lib/services/LogService.js

@@ -12,18 +12,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogService = void 0;
 const format_1 = require("date-fns/format");
 const decorators_1 = require("../decorators");
-const AppService_1 = require("./AppService");
+const ProcessService_1 = require("./ProcessService");
 const AppFileSystemService_1 = require("./AppFileSystemService");
+const types_1 = require("../types");
 let LogService = class LogService {
-    constructor(appService, fs) {
-        this.appService = appService;
+    constructor(processService, fs) {
+        this.processService = processService;
         this.fs = fs;
     }
+    get logLevel() {
+        const level = this.processService.getEnv("WS_LOG_LEVEL", types_1.LogLevel.WARNING);
+        if (types_1.LogLevel.values().includes(level)) {
+            return level;
+        }
+        return types_1.LogLevel.WARNING;
+    }
     get logName() {
         return "ws.log";
     }
     _log(type, ...data) {
-        if (type === "debug" && !this.appService.debug) {
+        if (!types_1.LogLevel.isGTE(this.logLevel, type)) {
             return;
         }
         const time = (0, format_1.format)(new Date(), "yyyy-MM-dd HH:mm:ss");
@@ -36,19 +44,19 @@ let LogService = class LogService {
         this.fs.appendFile(this.logName, `[${time}] ${type}: ${logData}\n`);
     }
     debug(...data) {
-        this._log("debug", ...data);
+        this._log(types_1.LogLevel.DEBUG, ...data);
     }
     log(...data) {
-        this._log("log", ...data);
+        this._log(types_1.LogLevel.LOG, ...data);
     }
     info(...data) {
-        this._log("info", ...data);
+        this._log(types_1.LogLevel.INFO, ...data);
     }
     warn(...data) {
-        this._log("warn", ...data);
+        this._log(types_1.LogLevel.WARNING, ...data);
     }
     error(...data) {
-        this._log("error", ...data);
+        this._log(types_1.LogLevel.ERROR, ...data);
     }
     clear() {
         this.fs.writeFile(this.logName, "");
@@ -57,6 +65,6 @@ let LogService = class LogService {
 exports.LogService = LogService;
 exports.LogService = LogService = __decorate([
     (0, decorators_1.Injectable)("LOG_SERVICE"),
-    __metadata("design:paramtypes", [AppService_1.AppService,
+    __metadata("design:paramtypes", [ProcessService_1.ProcessService,
         AppFileSystemService_1.AppFileSystemService])
 ], LogService);

package/lib/services/ProcessService.d.ts

@@ -8,4 +8,7 @@ export declare class ProcessService {
     cd(path: string): void;
     chdir(path: string): void;
     write(chunk: string | Buffer): boolean;
+    getEnv(key: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
+    setEnv(key: string, value: string): void;
 }

package/lib/services/ProcessService.js

@@ -14,16 +14,16 @@ const path_1 = __importDefault(require("path"));
 const decorators_1 = require("../decorators");
 let ProcessService = class ProcessService {
     get UID() {
-        if (process.getuid) {
-            return `${process.getuid()}`;
+        if (!process.getuid) {
+            return undefined;
         }
-        return undefined;
+        return `${process.getuid()}`;
     }
     get GID() {
-        if (process.getgid) {
-            return `${process.getgid()}`;
+        if (!process.getgid) {
+            return undefined;
         }
-        return undefined;
+        return `${process.getgid()}`;
     }
     get stdin() {
         return process.stdin;
@@ -46,6 +46,15 @@ let ProcessService = class ProcessService {
     write(chunk) {
         return this.stdout.write(chunk);
     }
+    getEnv(key, byDefault) {
+        if (key in process.env) {
+            return process.env[key];
+        }
+        return byDefault;
+    }
+    setEnv(key, value) {
+        process.env[key] = value;
+    }
 };
 exports.ProcessService = ProcessService;
 exports.ProcessService = ProcessService = __decorate([

package/lib/types/ApplicationOptions.d.ts

@@ -0,0 +1 @@
+export type ApplicationOptions = {};

package/lib/types/ApplicationOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/LogLevel.d.ts

@@ -0,0 +1,13 @@
+declare enum LogLevelEnum {
+    DEBUG = "debug",
+    LOG = "log",
+    INFO = "info",
+    WARNING = "warn",
+    ERROR = "error"
+}
+export type LogLevel = LogLevelEnum;
+export declare const LogLevel: typeof LogLevelEnum & {
+    values(): LogLevelEnum[];
+    isGTE(a: LogLevelEnum, b: LogLevelEnum): boolean;
+};
+export {};

package/lib/types/LogLevel.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevelEnum;
+(function (LogLevelEnum) {
+    LogLevelEnum["DEBUG"] = "debug";
+    LogLevelEnum["LOG"] = "log";
+    LogLevelEnum["INFO"] = "info";
+    LogLevelEnum["WARNING"] = "warn";
+    LogLevelEnum["ERROR"] = "error";
+})(LogLevelEnum || (LogLevelEnum = {}));
+exports.LogLevel = Object.assign({}, LogLevelEnum, {
+    values() {
+        return Object.values(LogLevelEnum);
+    },
+    isGTE(a, b) {
+        const values = exports.LogLevel.values();
+        return values.indexOf(a) <= values.indexOf(b);
+    }
+});

package/lib/types/index.d.ts

@@ -2,6 +2,7 @@ export * from "./DynamicModule";
 export * from "./EnvConfig";
 export * from "./FileSystemDriver";
 export * from "./InjectionToken";
+export * from "./LogLevel";
 export * from "./ModuleMetadata";
 export * from "./PackageManagerType";
 export * from "./PickProperties";

package/lib/types/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./DynamicModule"), exports);
 __exportStar(require("./EnvConfig"), exports);
 __exportStar(require("./FileSystemDriver"), exports);
 __exportStar(require("./InjectionToken"), exports);
+__exportStar(require("./LogLevel"), exports);
 __exportStar(require("./ModuleMetadata"), exports);
 __exportStar(require("./PackageManagerType"), exports);
 __exportStar(require("./PickProperties"), exports);