@wocker/core 1.0.22 → 1.0.23-beta.1

package/lib/core/ApplicationContext.js

@@ -31,27 +31,28 @@ class ApplicationContext {
         return __awaiter(this, void 0, void 0, function* () {
             const cli = this.get(cli_1.Cli);
             cli.command("").action(() => {
-                const module = this.container.getModule(this.module);
-                for (const [, container] of module.controllers) {
-                    if (!container.description) {
-                        continue;
-                    }
-                    console.info(`${container.description}:`);
-                    const spaceLength = container.commands.reduce((space, route) => {
-                        return route.commandNames.reduce((space, command) => {
-                            return Math.max(space, command.length + 2);
-                        }, space);
-                    }, 0);
-                    for (const route of container.commands) {
-                        if (!route.description) {
+                for (const [, module] of this.container.modules) {
+                    for (const [, container] of module.controllers) {
+                        if (!container.description) {
                             continue;
                         }
-                        for (const commandName of route.commandNames) {
-                            const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
-                            console.info(`  ${commandName} ${space} ${route.description}`);
+                        console.info(`${container.description}:`);
+                        const spaceLength = container.commands.reduce((space, route) => {
+                            return route.commandNames.reduce((space, command) => {
+                                return Math.max(space, command.length + 2);
+                            }, space);
+                        }, 0);
+                        for (const route of container.commands) {
+                            if (!route.description) {
+                                continue;
+                            }
+                            for (const commandName of route.commandNames) {
+                                const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
+                                console.info(`  ${commandName} ${space} ${route.description}`);
+                            }
                         }
+                        console.info("");
                     }
-                    console.info("");
                 }
             });
             return cli.run(args);

package/lib/core/ControllerWrapper.d.ts

@@ -10,7 +10,6 @@ export declare class ControllerWrapper<TInput = any> extends InstanceWrapper {
     commands: Route[];
     completions: Route[];
     constructor(module: Module, type: Type<TInput>);
-    getRoutes(): Route[];
     getCompletionCommands(name: string, command: string): Route[];
     run(route: Route, input: CommandInput): any;
 }

package/lib/core/ControllerWrapper.js

@@ -27,19 +27,6 @@ class ControllerWrapper extends InstanceWrapper_1.InstanceWrapper {
             }
         }
     }
-    getRoutes() {
-        const routes = [];
-        if (!this.type) {
-            return [];
-        }
-        for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
-            const route = new Route_1.Route(this.type, method);
-            if (route.isCommand || route.isCompletion) {
-                routes.push(route);
-            }
-        }
-        return routes;
-    }
     getCompletionCommands(name, command) {
         const completions = this.completions.filter((route) => {
             return route.completions.filter((completion) => {
@@ -52,7 +39,7 @@ class ControllerWrapper extends InstanceWrapper_1.InstanceWrapper {
         return this.completions.filter((route) => {
             return route.completions.filter((completion) => {
                 return completion.name === name && !completion.command;
-            });
+            }).length > 0;
         });
     }
     run(route, input) {

package/lib/core/InstanceWrapper.d.ts

@@ -1,4 +1,3 @@
-import "reflect-metadata";
 import { Module } from "./Module";
 import { Provider } from "../types/Provider";
 import { Type } from "../types/Type";

package/lib/core/InstanceWrapper.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceWrapper = void 0;
-require("reflect-metadata");
 const env_1 = require("../env");
 class InstanceWrapper {
     constructor(module, provider, _instance) {

package/lib/decorators/Global.d.ts

@@ -1,2 +1 @@
-import "reflect-metadata";
 export declare const Global: () => ClassDecorator;

package/lib/decorators/Global.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Global = void 0;
-require("reflect-metadata");
 const env_1 = require("../env");
 const Global = () => {
     return (target) => {

package/lib/decorators/Injectable.d.ts

@@ -1 +1,5 @@
-export declare const Injectable: (token?: string) => ClassDecorator;
+type Options = string | {
+    token?: string;
+};
+export declare const Injectable: (tokenOrOptions?: Options) => ClassDecorator;
+export {};

package/lib/decorators/Injectable.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injectable = void 0;
 const env_1 = require("../env");
-const Injectable = (token) => {
+const Injectable = (tokenOrOptions) => {
     return (target) => {
         Reflect.defineMetadata(env_1.INJECTABLE_WATERMARK, true, target);
+        if (!tokenOrOptions) {
+            return;
+        }
+        const { token } = typeof tokenOrOptions === "string" ? { token: tokenOrOptions } : tokenOrOptions;
         if (token) {
             Reflect.defineMetadata(env_1.INJECT_TOKEN_METADATA, token, target);
         }

package/lib/exceptions/UsageException.d.ts

@@ -0,0 +1,3 @@
+export declare class UsageException extends Error {
+    constructor(message: string);
+}

package/lib/exceptions/UsageException.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageException = void 0;
+class UsageException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UsageException";
+    }
+}
+exports.UsageException = UsageException;

package/lib/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from "./UsageException";

package/lib/exceptions/index.js

@@ -0,0 +1,17 @@
+"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 __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("./UsageException"), exports);

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import "reflect-metadata";
 export { Cli, CommandNotFoundError } from "@kearisp/cli";
 export * from "./core";
 export * from "./decorators";
+export * from "./exceptions";
 export * from "./makes";
 export * from "./services";
 export * from "./types";

package/lib/index.js

@@ -21,6 +21,7 @@ Object.defineProperty(exports, "Cli", { enumerable: true, get: function () { ret
 Object.defineProperty(exports, "CommandNotFoundError", { enumerable: true, get: function () { return cli_1.CommandNotFoundError; } });
 __exportStar(require("./core"), exports);
 __exportStar(require("./decorators"), exports);
+__exportStar(require("./exceptions"), exports);
 __exportStar(require("./makes"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./types"), exports);

package/lib/makes/AppConfig.d.ts

@@ -1,50 +1,37 @@
 import { EnvConfig } from "../types";
+import { PluginRef } from "../types/PluginRef";
+import { PresetRef } from "../types/PresetRef";
+import { ProjectRef, ProjectOldRef } from "../types/ProjectRef";
 import { PresetSource } from "./Preset";
-type ProjectData = {
-    id: string;
-    name?: string;
-    path?: string;
-    /** @deprecated */
-    src?: string;
-};
-type PluginData = {
-    name: string;
-    env: "latest" | "beta";
-};
-type PresetData = {
-    name: string;
-    source: PresetSource;
-    path?: string;
-};
 export type AppConfigProperties = {
     debug?: boolean;
     keystore?: string;
     logLevel?: "off" | "info" | "warn" | "error";
-    plugins?: PluginData[];
-    presets?: PresetData[];
-    projects?: ProjectData[];
+    plugins?: PluginRef[];
+    presets?: PresetRef[];
+    projects?: ProjectOldRef[];
     meta?: EnvConfig;
     env?: EnvConfig;
 };
-export declare abstract class AppConfig {
+export declare class AppConfig {
     debug?: boolean;
     keystore?: string;
     logLevel: "off" | "info" | "warn" | "error";
-    plugins: PluginData[];
-    presets: PresetData[];
-    projects: ProjectData[];
+    plugins: PluginRef[];
+    presets: PresetRef[];
+    projects: ProjectRef[];
     meta?: EnvConfig;
     env?: EnvConfig;
-    protected constructor(data: AppConfigProperties);
-    addPlugin(name: string, env?: PluginData["env"]): void;
+    constructor(data: AppConfigProperties);
+    addPlugin(name: string, env?: PluginRef["env"]): void;
     removePlugin(name: string): void;
-    getProject(id: string): ProjectData | undefined;
+    getProject(name: string): ProjectRef | undefined;
     addProject(id: string, name: string, path: string): void;
-    removeProject(id: string): void;
+    removeProject(name: string): void;
     registerPreset(name: string, source: PresetSource, path?: string): void;
     unregisterPreset(name: string): void;
     hasMeta(name: string): boolean;
-    getMeta(name: string): string | undefined;
+    getMeta(name: string, defaultValue?: string): string | undefined;
     getMeta(name: string, defaultValue: string): string;
     setMeta(name: string, value: string): void;
     unsetMeta(name: string): void;
@@ -52,7 +39,10 @@ export declare abstract class AppConfig {
     getEnv(name: string, defaultValue: string): string;
     setEnv(name: string, value: string): void;
     unsetEnv(name: string): void;
-    abstract save(): void;
+    /**
+     * @deprecated
+     */
+    save(): void;
     /**
      * @deprecated
      */
@@ -61,4 +51,3 @@ export declare abstract class AppConfig {
     toJsString(): string;
     toString(): string;
 }
-export {};

package/lib/makes/AppConfig.js

@@ -28,7 +28,13 @@ class AppConfig {
             return plugin;
         });
         this.presets = presets;
-        this.projects = projects;
+        this.projects = projects.map((ref) => {
+            const { id, name, path, src } = ref;
+            return {
+                name: (name || id),
+                path: (path || src)
+            };
+        });
     }
     addPlugin(name, env = "latest") {
         const plugin = this.plugins.find((plugin) => plugin.name === name);
@@ -48,42 +54,32 @@ class AppConfig {
         }
         this.plugins = this.plugins.filter((plugin) => plugin.name !== name);
     }
-    getProject(id) {
+    getProject(name) {
         if (!this.projects) {
             return;
         }
         return this.projects.find((projectData) => {
-            return projectData.id === id;
+            return projectData.name === name;
         });
     }
     addProject(id, name, path) {
-        if (!this.projects) {
-            this.projects = [];
-        }
-        let projectData = this.projects.find((projectData) => {
-            return projectData.id === id;
-        });
-        if (!projectData) {
+        let projectRef = this.getProject(name);
+        if (!projectRef) {
             this.projects.push({
-                id,
                 name,
-                path,
+                path
             });
             return;
         }
-        /* istanbul ignore next */
-        if (projectData.src) {
-            delete projectData.src;
-        }
-        projectData.name = name;
-        projectData.path = path;
+        projectRef.name = name;
+        projectRef.path = path;
     }
-    removeProject(id) {
+    removeProject(name) {
         if (this.projects.length === 0) {
             return;
         }
         this.projects = this.projects.filter((projectData) => {
-            return projectData.id !== id;
+            return projectData.name !== name;
         });
     }
     registerPreset(name, source, path) {
@@ -167,6 +163,10 @@ class AppConfig {
             delete this.env;
         }
     }
+    /**
+     * @deprecated
+     */
+    save() { }
     /**
      * @deprecated
      */

package/lib/makes/Config.d.ts

@@ -1,6 +1,12 @@
+/**
+ * @deprecated
+ */
 export type ConfigProperties = {
     name: string;
 };
+/**
+ * @deprecated
+ */
 export declare class Config<T extends ConfigProperties> {
     name: string;
     constructor(data: T);

package/lib/makes/Config.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
+/**
+ * @deprecated
+ */
+/* istanbul ignore next */
 class Config {
     constructor(data) {
         this.name = data.name;

package/lib/makes/ConfigCollection.d.ts

@@ -1,7 +1,13 @@
 import { Config, ConfigProperties } from "./Config";
+/**
+ * @deprecated
+ */
 interface Constructible<P extends ConfigProperties, C extends Config<P>> {
     new (props: P): C;
 }
+/**
+ * @deprecated
+ */
 export declare class ConfigCollection<C extends Config<P>, P extends ConfigProperties> {
     protected ConfigClass: Constructible<P, C>;
     items: C[];

package/lib/makes/ConfigCollection.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigCollection = void 0;
+/**
+ * @deprecated
+ */
+/* istanbul ignore next */
 class ConfigCollection {
     constructor(ConfigClass, items) {
         this.ConfigClass = ConfigClass;

package/lib/makes/File.d.ts

@@ -0,0 +1,32 @@
+import FS from "fs";
+import { Readable } from "stream";
+import { FileSystemDriver } from "../types";
+type ReadStreamOptions = {
+    start?: number;
+    end?: number;
+    encoding?: BufferEncoding;
+};
+type ReadlineStreamOptions = {
+    start?: number;
+    end?: number;
+    encoding?: ReadStreamOptions["encoding"];
+};
+export declare class File {
+    readonly path: string;
+    readonly flags: FS.OpenMode;
+    readonly mode: FS.Mode | null | undefined;
+    protected readonly driver: FileSystemDriver;
+    protected _fd: number;
+    protected _closed: boolean;
+    constructor(path: string, flags: FS.OpenMode | undefined, mode: FS.Mode | null | undefined, driver?: FileSystemDriver);
+    get fd(): number;
+    get closed(): boolean;
+    open(): void;
+    stat(): FS.Stats;
+    close(): void;
+    createReadStream(options?: ReadStreamOptions): FS.ReadStream;
+    createReadlineStream(options?: ReadlineStreamOptions): Readable;
+    readBytes(position?: number, size?: number): Buffer<ArrayBuffer>;
+    getLinePosition(line: number): number;
+}
+export {};

package/lib/makes/File.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = require("stream");
+const readline_1 = require("readline");
+class File {
+    constructor(path, flags = "r", mode, driver = fs_1.default) {
+        this.path = path;
+        this.flags = flags;
+        this.mode = mode;
+        this.driver = driver;
+        this._closed = true;
+        this.open();
+    }
+    get fd() {
+        return this._fd;
+    }
+    get closed() {
+        return this._closed;
+    }
+    open() {
+        if (!this.closed) {
+            return;
+        }
+        this._fd = this.driver.openSync(this.path, this.flags, this.mode);
+        this._closed = false;
+    }
+    stat() {
+        return this.driver.fstatSync(this.fd);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.driver.closeSync(this.fd);
+        this._closed = true;
+    }
+    createReadStream(options) {
+        const stream = this.driver.createReadStream(this.path, Object.assign(Object.assign({}, options || {}), { fd: this.fd, autoClose: false, emitClose: false }));
+        stream.on("close", () => {
+            this._closed = true;
+        });
+        return stream;
+    }
+    createReadlineStream(options) {
+        let { start, end, encoding } = options || {};
+        const startLine = typeof start !== "undefined"
+            ? this.getLinePosition(start)
+            : undefined;
+        const endLine = typeof end !== "undefined"
+            ? this.getLinePosition(end)
+            : undefined;
+        const stream = this.createReadStream({
+            encoding: encoding,
+            start: startLine,
+            end: endLine
+        });
+        const outputStream = new stream_1.Readable({
+            objectMode: true,
+            read() { }
+        });
+        const readline = (0, readline_1.createInterface)({
+            input: stream,
+            crlfDelay: Infinity
+        });
+        readline.on("line", (line) => {
+            outputStream.push(line);
+        });
+        readline.on("close", () => {
+            outputStream.push(null);
+        });
+        readline.on("error", (err) => {
+            outputStream.emit("error", err);
+        });
+        stream.on("error", (err) => {
+            outputStream.emit("error", err);
+        });
+        return outputStream;
+    }
+    readBytes(position = 0, size) {
+        const stats = this.stat();
+        if (position < 0 && typeof size === "undefined") {
+            size = position * -1;
+            position = stats.size - size;
+        }
+        else if (typeof size === "undefined") {
+            size = stats.size - position;
+        }
+        if (size <= 0) {
+            return Buffer.alloc(0);
+        }
+        const buffer = Buffer.alloc(size);
+        this.driver.readSync(this.fd, buffer, 0, size, position);
+        return buffer;
+    }
+    getLinePosition(line) {
+        var _a, _b;
+        if (line === 0) {
+            throw new Error("Line number must be a non-zero");
+        }
+        const bufferSize = 1024, isForward = line > 0, targetLine = Math.abs(line), stats = this.stat();
+        let position = isForward ? 0 : stats.size, currentLine = 0, currentOffset = isForward ? 0 : stats.size + 1, stump = "";
+        while (isForward ? position < stats.size : position > 0) {
+            const readSize = isForward
+                ? Math.min(bufferSize, stats.size - position)
+                : Math.min(bufferSize, position);
+            if (!isForward) {
+                position -= readSize;
+            }
+            const chunk = this.readBytes(position, readSize).toString(), lines = (isForward ? stump + chunk : chunk + stump).split("\n");
+            if (isForward) {
+                position += readSize;
+            }
+            if (isForward ? position === stats.size : position === 0) {
+                stump = "";
+            }
+            else {
+                stump = isForward
+                    ? (_a = lines.pop()) !== null && _a !== void 0 ? _a : ""
+                    : (_b = lines.shift()) !== null && _b !== void 0 ? _b : "";
+            }
+            for (let i = isForward ? 0 : lines.length - 1; isForward ? i < lines.length : i >= 0; isForward ? i++ : i--) {
+                const lineLength = Buffer.byteLength(`${lines[i]}\n`);
+                currentLine++;
+                if (currentLine === targetLine) {
+                    return isForward ? currentOffset : currentOffset - lineLength;
+                }
+                currentOffset += isForward ? lineLength : -lineLength;
+            }
+        }
+        return isForward
+            ? Math.min(currentOffset, stats.size)
+            : Math.max(currentOffset, 0);
+    }
+}
+exports.File = File;

package/lib/makes/FileSystem.d.ts

@@ -1,24 +1,44 @@
-import fs, { RmOptions, Stats, WriteFileOptions, MakeDirectoryOptions } from "fs";
-type ReaddirOptions = fs.ObjectEncodingOptions & {
+import FS from "fs";
+import { Readable } from "stream";
+import { FileSystemDriver, ReadStreamOptions, WriteStreamOptions } from "../types";
+import { File } from "./File";
+type ReaddirOptions = FS.ObjectEncodingOptions & {
     recursive?: boolean | undefined;
 };
+type ReadlineOptions = {
+    encoding?: BufferEncoding;
+    start?: number;
+    end?: number;
+};
 export declare class FileSystem {
     protected readonly source: string;
-    constructor(source: string);
+    protected readonly driver: FileSystemDriver;
+    constructor(source: string, driver?: FileSystemDriver);
     path(...parts: string[]): string;
+    cd(path: string): FileSystem;
+    readBytes(path: string, position?: number, size?: number): Buffer<ArrayBuffer>;
+    open(path: string, flags: FS.OpenMode, mode?: FS.Mode | null): File;
     basename(...parts: string[]): string;
     exists(...parts: string[]): boolean;
-    stat(...parts: string[]): Stats;
-    mkdir(path?: string, options?: MakeDirectoryOptions): void;
-    readdir(path: string): string[];
+    stat(...parts: string[]): FS.Stats;
+    mkdir(path?: string, options?: FS.MakeDirectoryOptions): void;
+    readdir(path?: string, options?: {
+        recursive?: boolean;
+    }): string[];
+    /**
+     * @deprecated
+     */
     readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
-    readFile(path: string): Buffer;
+    readFile(path: string): string | Buffer;
     readJSON(...paths: string[]): any;
-    writeFile(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions): void;
-    writeJSON(path: string, data: any, options?: WriteFileOptions): void;
-    appendFile(path: string, data: string | Uint8Array, options?: WriteFileOptions): void;
-    rm(path: string, options?: RmOptions): void;
-    createWriteStream(path: string, options?: BufferEncoding): fs.WriteStream;
-    createReadStream(path: string, options?: BufferEncoding): fs.ReadStream;
+    writeFile(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: FS.WriteFileOptions): void;
+    writeJSON(path: string, data: any, options?: FS.WriteFileOptions): void;
+    appendFile(path: string, data: string | Uint8Array, options?: FS.WriteFileOptions): void;
+    rm(path: string, options?: FS.RmOptions): void;
+    createWriteStream(path: string, options?: WriteStreamOptions): FS.WriteStream;
+    createReadStream(path: string, options?: ReadStreamOptions): FS.ReadStream;
+    createReadlineStream(path: string, options?: ReadlineOptions): Readable;
+    getLinePosition(path: string, line: number): number;
+    watch(path: string, options?: FS.WatchOptions): FS.FSWatcher;
 }
 export {};