@wocker/ws 1.0.24 → 1.0.26

package/README.md

@@ -4,7 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@wocker/ws.svg)](https://www.npmjs.com/package/@wocker/ws)
 [![Publish](https://github.com/kearisp/wocker-ws/actions/workflows/publish-latest.yml/badge.svg?event=release)](https://github.com/kearisp/wocker-ws/actions/workflows/publish-latest.yml)
-[![License](https://img.shields.io/npm/l/@wocker/ws)](https://github.com/kearisp/wocker-ws/blob/main/LICENSE)
+[![License](https://img.shields.io/npm/l/@wocker/ws)](https://github.com/kearisp/wocker-ws/blob/master/LICENSE)
 
 [![npm total downloads](https://img.shields.io/npm/dt/@wocker/ws.svg)](https://www.npmjs.com/package/@wocker/ws)
 [![bundle size](https://img.shields.io/bundlephobia/minzip/@wocker/ws)](https://bundlephobia.com/package/@wocker/ws)

package/lib/AppModule.js

@@ -0,0 +1,42 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppModule = void 0;
+const core_1 = require("@wocker/core");
+const modules_1 = require("./modules");
+let AppModule = class AppModule {
+};
+exports.AppModule = AppModule;
+exports.AppModule = AppModule = __decorate([
+    (0, core_1.Global)(),
+    (0, core_1.Module)({
+        imports: [
+            modules_1.CoreModule,
+            modules_1.DnsModule.register(),
+            modules_1.PluginModule.register(),
+            modules_1.ProjectModule,
+            modules_1.PresetModule,
+            modules_1.DockerModule,
+            modules_1.KeystoreModule,
+            modules_1.ProxyModule
+        ],
+        exports: [
+            modules_1.DockerService,
+            modules_1.CertService,
+            modules_1.ContainerService,
+            modules_1.ImageService,
+            modules_1.ProxyService,
+            modules_1.KeystoreService,
+            modules_1.PresetRepository,
+            modules_1.PresetService,
+            modules_1.ProjectService,
+            core_1.ProcessService,
+            modules_1.ProjectRepository
+        ]
+    })
+], AppModule);

package/lib/env.d.ts

@@ -1,8 +1,7 @@
-export declare const WOCKER_VERSION = "1.0.24";
-export declare const NODE_ENV: string;
+export { WOCKER_VERSION } from "@wocker/core";
+export declare const WOCKER_DATA_DIR: string;
 export declare const ROOT_DIR: string;
 export declare const PRESETS_DIR: string;
 export declare const PLUGINS_DIR: string;
-export declare const WOCKER_DATA_DIR: string;
 export declare const VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
 export declare const KEYTAR_SERVICE: string;

package/lib/env.js

@@ -1,46 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.WOCKER_DATA_DIR = exports.PLUGINS_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
-const OS = __importStar(require("os"));
-const Path = __importStar(require("path"));
-exports.WOCKER_VERSION = "1.0.24";
-exports.NODE_ENV = process.env.NODE_ENV;
-exports.ROOT_DIR = Path.join(__dirname, "..");
-exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
-exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "plugins");
-exports.WOCKER_DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
+exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.PLUGINS_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.WOCKER_DATA_DIR = exports.WOCKER_VERSION = void 0;
+var core_1 = require("@wocker/core");
+Object.defineProperty(exports, "WOCKER_VERSION", { enumerable: true, get: function () { return core_1.WOCKER_VERSION; } });
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.WOCKER_DATA_DIR = process.env.WS_DIR || path_1.default.join(os_1.default.homedir(), ".workspace");
+exports.ROOT_DIR = path_1.default.join(__dirname, "..");
+exports.PRESETS_DIR = path_1.default.join(exports.ROOT_DIR, "presets");
+exports.PLUGINS_DIR = path_1.default.join(exports.ROOT_DIR, "plugins");
 exports.VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
 exports.KEYTAR_SERVICE = process.env.WOCKER_KEYTAR_SERVICE || "wocker";

package/lib/main.d.ts

@@ -1,3 +1,2 @@
-export declare const app: {
-    run(args: string[]): Promise<void>;
-};
+#!/usr/bin/env node
+export {};

package/lib/main.js

@@ -1,36 +1,34 @@
+#!/usr/bin/env node
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.app = void 0;
 const core_1 = require("@wocker/core");
 const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
-const RootModule_1 = require("./RootModule");
-exports.app = {
-    async run(args) {
-        const context = await core_1.Factory.create(RootModule_1.RootModule), appConfigService = context.get(core_1.AppConfigService), logService = context.get(core_1.LogService);
-        try {
-            const res = await context.run(args);
-            if (res) {
-                process.stdout.write(res);
-                process.stdout.write("\n");
-            }
+const AppModule_1 = require("./AppModule");
+(async () => {
+    const context = await core_1.Factory.create(AppModule_1.AppModule), appConfigService = context.get(core_1.AppConfigService), logService = context.get(core_1.LogService);
+    try {
+        const res = await context.run(process.argv);
+        if (res) {
+            process.stdout.write(res);
+            process.stdout.write("\n");
         }
-        catch (err) {
-            if (typeof err.name === "string" && ["ExitPromptError", "CancelPromptError", "AbortPromptError"].includes(err.name)) {
-                return;
-            }
-            console.error(yoctocolors_cjs_1.default.red(err.message));
-            if (err instanceof core_1.UsageException || err.name === "UsageException") {
-                return;
-            }
-            if (err instanceof core_1.CommandNotFoundError) {
-                return;
-            }
-            if (appConfigService.debug) {
-                logService.error(err.stack || err.toString());
-            }
+    }
+    catch (err) {
+        if (typeof err.name === "string" && ["ExitPromptError", "CancelPromptError", "AbortPromptError"].includes(err.name)) {
+            return;
+        }
+        console.error(yoctocolors_cjs_1.default.red(err.message));
+        if (err instanceof core_1.UsageException || err.name === "UsageException") {
+            return;
+        }
+        if (err instanceof core_1.CommandNotFoundError) {
+            return;
+        }
+        if (appConfigService.debug) {
+            logService.error(err.stack || err.toString());
         }
     }
-};
+})();

package/lib/makes/GithubClient.d.ts

@@ -2,13 +2,34 @@ import { AxiosInstance } from "axios";
 type RepositoryInfo = {
     default_branch: string;
 };
+export type GithubTag = {
+    name: string;
+    zipball_url: string;
+    tarball_url: string;
+    commit: {
+        sha: string;
+        url: string;
+    };
+    node_id: string;
+};
+export type GithubBranch = {
+    name: string;
+    commit: {
+        sha: string;
+        url: string;
+    };
+    protected: boolean;
+};
 export declare class GithubClient {
-    owner: string;
-    repository: string;
+    readonly owner: string;
+    readonly repository: string;
     constructor(owner: string, repository: string);
     get axios(): AxiosInstance;
     getInfo(): Promise<RepositoryInfo>;
-    getFile(branch: string, path: string): Promise<any>;
+    getBranches(): Promise<GithubBranch[]>;
+    getTags(): Promise<GithubTag[]>;
+    getFile(ref: string, path: string): Promise<any>;
+    downloadZipByUrl(url: string, dirPath: string): Promise<void>;
     download(branch: string, dirPath: string): Promise<void>;
 }
 export {};

package/lib/makes/GithubClient.js

@@ -15,7 +15,7 @@ class GithubClient {
         return axios_1.default.create({
             headers: {
                 "User-Agent": "Wocker"
-            },
+            }
         });
     }
     async getInfo() {
@@ -26,16 +26,27 @@ class GithubClient {
         });
         return response.data;
     }
-    async getFile(branch, path) {
-        const response = await this.axios.get(`https://raw.githubusercontent.com/${this.owner}/${this.repository}/${branch}/${path}`, {
+    async getBranches() {
+        const response = await this.axios
+            .get(`https://api.github.com/repos/${this.owner}/${this.repository}/branches`);
+        return response.data;
+    }
+    async getTags() {
+        const response = await this.axios
+            .get(`https://api.github.com/repos/${this.owner}/${this.repository}/tags`);
+        return response.data;
+    }
+    async getFile(ref, path) {
+        const res = await this.axios
+            .get(`https://raw.githubusercontent.com/${this.owner}/${this.repository}/${ref}/${path}`, {
             headers: {
                 "Accept": "application/vnd.github+json"
             }
         });
-        return response.data;
+        return res.data;
     }
-    async download(branch, dirPath) {
-        const res = await this.axios.get(`https://github.com/${this.owner}/${this.repository}/archive/refs/heads/${branch}.zip`, {
+    async downloadZipByUrl(url, dirPath) {
+        const res = await this.axios.get(url, {
             responseType: "stream"
         });
         const fs = new core_1.FileSystem(dirPath);
@@ -61,5 +72,8 @@ class GithubClient {
             pipe.on("error", reject);
         });
     }
+    async download(branch, dirPath) {
+        return this.downloadZipByUrl(`https://api.github.com/repos/${this.owner}/${this.repository}/zipball/${branch}`, dirPath);
+    }
 }
 exports.GithubClient = GithubClient;

package/lib/makes/Version.d.ts

@@ -0,0 +1,22 @@
+type VersionData = {
+    major: number;
+    minor: number;
+    patch: number;
+    tag?: string;
+    build?: number;
+};
+export declare class Version {
+    static readonly REGEXP: RegExp;
+    protected static cache: Map<string, Version>;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly tag?: string;
+    readonly build?: number;
+    constructor(data: VersionData);
+    parts(): number[];
+    compare(version: string | Version): number;
+    static valid(version: string): boolean;
+    static parse(version: string): Version;
+}
+export {};

package/lib/makes/Version.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+class Version {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    parts() {
+        return [
+            this.major,
+            this.minor,
+            this.patch,
+            this.build ?? 0
+        ];
+    }
+    compare(version) {
+        if (typeof version === "string") {
+            version = Version.parse(version);
+        }
+        const a = this.parts(), b = version.parts();
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            if (i === 3) {
+                if (this.tag && !version.tag)
+                    return -1;
+                else if (!this.tag && version.tag)
+                    return 1;
+                else if (this.tag !== version.tag)
+                    return this.tag < version.tag ? -1 : 1;
+            }
+            const diff = (a[i] ?? 0) - (b[i] ?? 0);
+            if (diff !== 0) {
+                return diff > 0 ? 1 : -1;
+            }
+        }
+        return 0;
+    }
+    static valid(version) {
+        return Version.REGEXP.test(version);
+    }
+    static parse(version) {
+        if (!Version.cache.has(version)) {
+            if (!Version.REGEXP.test(version)) {
+                throw new RangeError("Invalid version format");
+            }
+            const [, major, minor, patch, tag, build] = Version.REGEXP.exec(version) || [];
+            Version.cache.set(version, new Version({
+                major: parseInt(major),
+                minor: parseInt(minor),
+                patch: parseInt(patch),
+                tag,
+                build: build ? parseInt(build) : undefined
+            }));
+        }
+        return Version.cache.get(version);
+    }
+}
+exports.Version = Version;
+Version.REGEXP = /^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)(?:\.(\d+))?)?/;
+Version.cache = new Map();

package/lib/makes/VersionRange.d.ts

@@ -0,0 +1,6 @@
+import { VersionRule } from "./VersionRule";
+export declare class VersionRange {
+    protected rules: VersionRule[][];
+    constructor(rules: VersionRule[][]);
+    static parse(range: string): VersionRange;
+}

package/lib/makes/VersionRange.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionRange = void 0;
+const VersionRule_1 = require("./VersionRule");
+class VersionRange {
+    constructor(rules) {
+        this.rules = rules;
+    }
+    static parse(range) {
+        const rules = range.split("||").map((range) => {
+            return range.split(" ").map((rule) => {
+                return VersionRule_1.VersionRule.parse(rule);
+            });
+        });
+        return new VersionRange(rules);
+    }
+}
+exports.VersionRange = VersionRange;

package/lib/makes/VersionRule.d.ts

@@ -0,0 +1,24 @@
+import { Version } from "./Version";
+type VersionRuleData = {
+    prefix?: string;
+    major?: number;
+    minor?: number;
+    patch?: number;
+    tag?: string;
+    build?: number;
+};
+export declare class VersionRule {
+    static readonly REGEXP: RegExp;
+    protected static map: Map<string, VersionRule>;
+    readonly prefix?: string;
+    readonly major?: number;
+    readonly minor?: number;
+    readonly patch?: number;
+    readonly tag?: string;
+    readonly build?: number;
+    constructor(data: VersionRuleData);
+    get version(): Version;
+    match(version: string | Version, withTag?: boolean): boolean;
+    static parse(rule: string): VersionRule;
+}
+export {};

package/lib/makes/VersionRule.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionRule = void 0;
+const Version_1 = require("./Version");
+class VersionRule {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    get version() {
+        return new Version_1.Version({
+            major: this.major ?? 0,
+            minor: this.minor ?? 0,
+            patch: this.patch ?? 0,
+            tag: this.tag,
+            build: this.build
+        });
+    }
+    match(version, withTag) {
+        if (typeof version === "string") {
+            version = Version_1.Version.parse(version);
+        }
+        if ((!withTag || this.tag) && this.tag !== version.tag) {
+            return false;
+        }
+        const cmp = version.compare(this.version);
+        switch (this.prefix) {
+            case ">":
+                return cmp > 0;
+            case ">=":
+                return cmp >= 0;
+            case "<":
+                return cmp < 0;
+            case "<=":
+                return cmp <= 0;
+            case "^":
+                return (this.major === version.major &&
+                    cmp >= 0);
+            case "~":
+                return (this.major === version.major &&
+                    this.minor === version.minor &&
+                    cmp >= 0);
+            default:
+                return ((this.major === undefined || this.major === version.major) &&
+                    (this.minor === undefined || this.minor === version.minor) &&
+                    (this.patch === undefined || this.patch === version.patch));
+        }
+    }
+    static parse(rule) {
+        if (!VersionRule.map.has(rule)) {
+            if (!VersionRule.REGEXP.test(rule)) {
+                throw new Error("Invalid version rule");
+            }
+            const [, prefix, major, minor, patch, tag, build, onlyTag] = VersionRule.REGEXP.exec(rule) || [];
+            VersionRule.map.set(rule, new VersionRule({
+                prefix,
+                major: major && major !== "x" && major !== "*" ? parseInt(major) : undefined,
+                minor: minor && minor !== "x" ? parseInt(minor) : undefined,
+                patch: patch && patch !== "x" ? parseInt(patch) : undefined,
+                tag: tag || onlyTag,
+                build: build && build !== "x" ? parseInt(build) : undefined
+            }));
+        }
+        return VersionRule.map.get(rule);
+    }
+}
+exports.VersionRule = VersionRule;
+VersionRule.REGEXP = /^(?:(\^|~|<=|>=|<|>)?(x|\d+)(?:\.(\*|x|\d+))?(?:\.(x|\d+))?(?:-([a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)(?:\.(\d+))?)?|([a-zA-Z0-9]+(?:-[a-zAZ0-9]+)*))$/;
+VersionRule.map = new Map();

package/lib/makes/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./Http";
 export * from "./Plugin";
+export * from "./Version";
+export * from "./VersionRule";

package/lib/makes/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Http"), exports);
 __exportStar(require("./Plugin"), exports);
+__exportStar(require("./Version"), exports);
+__exportStar(require("./VersionRule"), exports);

package/lib/modules/core/index.d.ts

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

package/lib/modules/{app → core}/index.js

@@ -6,27 +6,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppModule = void 0;
+exports.CoreModule = void 0;
 const core_1 = require("@wocker/core");
-const env_1 = require("../../env");
-let AppModule = class AppModule {
+const CompletionController_1 = require("./controllers/CompletionController");
+const DebugController_1 = require("./controllers/DebugController");
+const ExperimentalController_1 = require("./controllers/ExperimentalController");
+let CoreModule = class CoreModule {
 };
-exports.AppModule = AppModule;
-exports.AppModule = AppModule = __decorate([
+exports.CoreModule = CoreModule;
+exports.CoreModule = CoreModule = __decorate([
+    (0, core_1.Global)(),
     (0, core_1.Module)({
-        providers: [
-            {
-                provide: core_1.WOCKER_VERSION_KEY,
-                useValue: env_1.WOCKER_VERSION
-            },
-            {
-                provide: core_1.WOCKER_DATA_DIR_KEY,
-                useValue: env_1.WOCKER_DATA_DIR
-            }
-        ],
-        exports: [
-            core_1.WOCKER_VERSION_KEY,
-            core_1.WOCKER_DATA_DIR_KEY
+        controllers: [
+            CompletionController_1.CompletionController,
+            DebugController_1.DebugController,
+            ExperimentalController_1.ExperimentalController
         ]
     })
-], AppModule);
+], CoreModule);

package/lib/modules/dns/controllers/DnsController.d.ts

@@ -0,0 +1,7 @@
+import { DnsService } from "../services/DnsService";
+export declare class DnsController {
+    protected readonly dnsService: DnsService;
+    constructor(dnsService: DnsService);
+    start(restart?: boolean, rebuild?: boolean): Promise<void>;
+    stop(): Promise<void>;
+}

package/lib/modules/dns/controllers/DnsController.js

@@ -0,0 +1,47 @@
+"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 __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.DnsController = void 0;
+const core_1 = require("@wocker/core");
+const DnsService_1 = require("../services/DnsService");
+let DnsController = class DnsController {
+    constructor(dnsService) {
+        this.dnsService = dnsService;
+    }
+    async start(restart, rebuild) {
+        await this.dnsService.start(restart, rebuild);
+    }
+    async stop() {
+        await this.dnsService.stop();
+    }
+};
+exports.DnsController = DnsController;
+__decorate([
+    (0, core_1.Command)("dns:start"),
+    __param(0, (0, core_1.Option)("restart", "r")),
+    __param(1, (0, core_1.Option)("rebuild", "b")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean, Boolean]),
+    __metadata("design:returntype", Promise)
+], DnsController.prototype, "start", null);
+__decorate([
+    (0, core_1.Command)("dns:stop"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DnsController.prototype, "stop", null);
+exports.DnsController = DnsController = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [DnsService_1.DnsService])
+], DnsController);

package/lib/modules/dns/index.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from "@wocker/core";
+export declare class DnsModule {
+    static register(): DynamicModule;
+}

package/lib/modules/dns/index.js

@@ -0,0 +1,41 @@
+"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 DnsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsModule = void 0;
+const core_1 = require("@wocker/core");
+const core_2 = require("../core");
+const docker_1 = require("../docker");
+const DnsController_1 = require("./controllers/DnsController");
+const DnsService_1 = require("./services/DnsService");
+let DnsModule = DnsModule_1 = class DnsModule {
+    static register() {
+        return {
+            module: DnsModule_1,
+            inject: [core_1.AppConfigService],
+            useFactory: (appConfigService) => {
+                if (!appConfigService.isExperimentalEnabled("dns")) {
+                    return {};
+                }
+                return {
+                    imports: [docker_1.DockerModule],
+                    controllers: [DnsController_1.DnsController],
+                    providers: [DnsService_1.DnsService]
+                };
+            }
+        };
+    }
+};
+exports.DnsModule = DnsModule;
+exports.DnsModule = DnsModule = DnsModule_1 = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            core_2.CoreModule
+        ]
+    })
+], DnsModule);