@wocker/ws 1.0.1

package/lib/makes/FS.js

@@ -0,0 +1,317 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FS = void 0;
+var fs = _interopRequireWildcard(require("fs"));
+var Path = _interopRequireWildcard(require("path"));
+var _readableStream = require("readable-stream");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class FS {
+  static async access(path) {
+    return new Promise((resolve, reject) => {
+      fs.access(path, err => {
+        if (!err) {
+          resolve(null);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Asynchronously tests whether or not the given path exists by checking with the file system.
+   * @param path path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
+   */
+  static async exists(path) {
+    return new Promise(resolve => {
+      fs.exists(path, exists => {
+        resolve(exists);
+      });
+    });
+  }
+  static existsSync(path) {
+    return fs.existsSync(path);
+  }
+  static async mkdir(dirPath, options = {}) {
+    return new Promise((resolve, reject) => {
+      fs.mkdir(dirPath, options, err => {
+        if (!err) {
+          resolve();
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static mkdirSync(path, options) {
+    return fs.mkdirSync(path, options);
+  }
+  static async readdir(path) {
+    return new Promise((resolve, reject) => {
+      fs.readdir(path, (err, files) => {
+        if (!err) {
+          resolve(files);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static async readdirFiles(path, options) {
+    const {
+      recursive = false
+    } = options || {};
+    if (recursive) {
+      const names = await FS.readdir(path);
+      let res = [];
+      for (const name of names) {
+        const filePath = Path.join(path, name);
+        let sub = [name];
+        const stats = await FS.stat(filePath);
+        if (stats.isDirectory()) {
+          sub = (await FS.readdirFiles(filePath, {
+            recursive: true
+          })).map(subName => {
+            return Path.join(name, subName);
+          });
+        }
+        res = [...res, ...sub];
+      }
+      return res;
+    }
+    return new Promise((resolve, reject) => {
+      fs.readdir(path, {
+        withFileTypes: true
+      }, (err, files) => {
+        if (err) {
+          return reject(err);
+        }
+        const names = files.filter(dirent => {
+          return dirent.isFile();
+        }).map(dirent => {
+          return dirent.name;
+        });
+        resolve(names);
+      });
+    });
+  }
+  static async appendFile(path, data, options) {
+    return new Promise((resolve, reject) => {
+      fs.appendFile(path, data, options, (error, data) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  }
+  static appendFileSync(path, data, options) {
+    return fs.appendFileSync(path, data, options);
+  }
+  static read() {
+    //
+  }
+  static async readBytes(filePath, position = 0, size) {
+    if (position < 0 && typeof size === "undefined") {
+      const stats = await FS.stat(filePath);
+      size = BigInt(position) * -1n;
+      position = BigInt(stats.size) - size;
+      if (position < 0n) {
+        position = 0;
+      }
+    } else if (typeof size === "undefined") {
+      const stats = await FS.stat(filePath);
+      if (typeof stats.size !== "bigint" && typeof position !== "bigint") {
+        size = stats.size - position;
+      } else {
+        size = BigInt(stats.size) - BigInt(position);
+      }
+    }
+    if (size < 0n) {
+      // throw Error(`Buffer size ${size}`);
+
+      return Buffer.alloc(0);
+    }
+    const buffer = Buffer.alloc(Number(size));
+    return new Promise((resolve, reject) => {
+      fs.open(filePath, (err, file) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        fs.read(file, buffer, 0, buffer.length, position, (err, bytesRead, buffer) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(buffer);
+        });
+      });
+    });
+  }
+  static async readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, (err, data) => {
+        if (!err) {
+          resolve(data);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static readFileSync(filePath) {
+    return fs.readFileSync(filePath);
+  }
+  static async writeFile(filePath, data, options) {
+    return new Promise((resolve, reject) => {
+      fs.writeFile(filePath, data, options, err => {
+        if (!err) {
+          resolve();
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static writeFileSync(path, data, options) {
+    return fs.writeFileSync(path, data, options);
+  }
+  static createWriteStream(path) {
+    return fs.createWriteStream(path);
+  }
+  static async readJSON(filePath) {
+    return FS.readFile(filePath).then(res => {
+      try {
+        const str = res.toString();
+        return JSON.parse(str);
+      } catch (ignore) {
+        return {};
+      }
+    });
+  }
+  static async writeJSON(filePath, data) {
+    const json = JSON.stringify(data, null, 4);
+    return FS.writeFile(filePath, json);
+  }
+  static async unlink(filePath) {
+    return new Promise((resolve, reject) => {
+      fs.unlink(filePath, err => {
+        if (!err) {
+          resolve();
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static watch(filename, options) {
+    return fs.watch(filename, options);
+  }
+  static stat(filename, options) {
+    return new Promise((resolve, reject) => {
+      fs.stat(filename, options, (err, stats) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(stats);
+        }
+      });
+    });
+  }
+  static createReadStream(path, options) {
+    return fs.createReadStream(path, options);
+  }
+  static createReadLinesStream(path, count) {
+    const write = new _readableStream.PassThrough();
+    (async () => {
+      if (typeof count === "undefined" || count > 0) {
+        const stats = await FS.stat(path);
+        const resLines = [""];
+        let position = 0n;
+        while (position < stats.size) {
+          let size = BigInt(count ? 64 * count : 255);
+          if (position + size > stats.size) {
+            size = BigInt(stats.size) - position;
+          }
+          const buffer = await FS.readBytes(path, position, size);
+          const lines = buffer.toString("utf-8").split("\n");
+          position += size;
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (i === 0) {
+              resLines[resLines.length - 1] = (resLines[resLines.length - 1] || "") + line;
+            } else {
+              resLines.push(line);
+            }
+          }
+          if (resLines.length > count + 1) {
+            break;
+          }
+        }
+        for (let i = 0; i < (count || resLines.length); i++) {
+          write.write(resLines[i]);
+        }
+      } else if (count < 0) {
+        const stats = await FS.stat(path);
+        const resLines = [""];
+        let position = BigInt(stats.size);
+        while (position > 0n) {
+          // let size = BigInt(64 * count * -1);
+          let size = BigInt(2 * count * -1);
+          position -= size;
+          if (position < 0) {
+            size = position + size;
+            position = 0n;
+          }
+          const buffer = await FS.readBytes(path, position, size);
+          const lines = buffer.toString("utf-8").split("\n").reverse();
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (i === 0) {
+              resLines[0] = line + (resLines[0] || "");
+            } else {
+              resLines.unshift(line);
+            }
+          }
+          if (resLines.length > count * -1 + 1) {
+            break;
+          }
+        }
+        const lines = resLines.slice(count - 1);
+        for (let i = 0; i < lines.length; i++) {
+          write.write(lines[i]);
+        }
+        write.end();
+      }
+    })();
+    return write;
+  }
+  static async copyFile(src, dest) {
+    new Promise((resolve, reject) => {
+      fs.copyFile(src, dest, err => {
+        if (!err) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  static async rm(path, options) {
+    return new Promise((resolve, reject) => {
+      fs.rm(path, options, err => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(undefined);
+      });
+    });
+  }
+}
+exports.FS = FS;

package/lib/makes/LineConvertStream.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from "stream";
+import { Mutex } from "async-mutex";
+declare class LineConvertStream extends Readable {
+    protected stream: NodeJS.ReadableStream;
+    protected buf: string;
+    protected mutex: Mutex;
+    constructor(stream: NodeJS.ReadableStream);
+    _read(size: number): void;
+    process(chunk: any): Promise<void>;
+}
+export { LineConvertStream };

package/lib/makes/LineConvertStream.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LineConvertStream = void 0;
+var _stream = require("stream");
+var _asyncMutex = require("async-mutex");
+class LineConvertStream extends _stream.Readable {
+  buf = "";
+  mutex = new _asyncMutex.Mutex();
+  constructor(stream) {
+    super();
+    this.stream = stream;
+    this.stream.on("data", chunk => this.process(chunk));
+    this.stream.on("end", () => {
+      this.push(null);
+    });
+    this.stream.on("close", () => {
+      this.destroy();
+    });
+  }
+  _read(size) {
+    //
+  }
+  async process(chunk) {
+    await this.mutex.acquire();
+    this.buf += chunk.toString();
+    try {
+      let pos;
+      while ((pos = this.buf.indexOf("\n")) >= 0) {
+        if (pos === 0) {
+          this.buf = this.buf.slice(0);
+          continue;
+        }
+        const line = this.buf.slice(0, pos);
+        this.buf = this.buf.slice(pos + 1);
+        this.push(line);
+      }
+    } finally {
+      this.mutex.release();
+    }
+  }
+}
+exports.LineConvertStream = LineConvertStream;

package/lib/makes/Logger.d.ts

@@ -0,0 +1,7 @@
+export declare class Logger {
+    static log(...data: any[]): void;
+    static info(...data: any[]): void;
+    static warning(...data: any[]): void;
+    static error(...data: any[]): void;
+    static _log(type: string, ...data: any[]): void;
+}

package/lib/makes/Logger.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Logger = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _format = _interopRequireDefault(require("date-fns/format"));
+var _env = require("../env");
+var _FS = require("./FS");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class Logger {
+  static log(...data) {
+    Logger._log("log", ...data);
+  }
+  static info(...data) {
+    Logger._log("info", ...data);
+  }
+  static warning(...data) {
+    Logger._log("warning", ...data);
+  }
+  static error(...data) {
+    Logger._log("error", ...data);
+  }
+  static _log(type, ...data) {
+    const time = (0, _format.default)(new Date(), "yyyy-MM-dd hh:mm:ss");
+    const logPath = Path.join(_env.DATA_DIR, "ws.log");
+    const logData = data.map(item => {
+      return typeof item !== "string" ? JSON.stringify(item) : item;
+    }).join(" ");
+    if (!_FS.FS.existsSync(logPath)) {
+      _FS.FS.writeFileSync(logPath, "");
+    }
+    _FS.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
+  }
+}
+exports.Logger = Logger;

package/lib/makes/Model.d.ts

@@ -0,0 +1,5 @@
+export declare class Model {
+    attributes: {};
+    constructor(attributes?: any);
+    save(): Promise<void>;
+}

package/lib/makes/Model.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Model = void 0;
+class Model {
+  attributes = {};
+  constructor(attributes = {}) {
+    this.attributes = attributes;
+  }
+  async save() {
+    //
+  }
+}
+exports.Model = Model;

package/lib/makes/MySQL.d.ts

@@ -0,0 +1,15 @@
+type Options = string | {
+    ssl?: boolean;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+export declare class MySQL {
+    protected connection: any;
+    protected options: Options;
+    constructor(options: Options);
+    query(sql: string): Promise<void>;
+}
+export {};

package/lib/makes/MySQL.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MySQL = void 0;
+// import {createConnection} from "mysql";
+
+class MySQL {
+  constructor(options) {
+    // this.connection = createConnection(options);
+  }
+  async query(sql) {
+    // this.connection.connect();
+    //
+    // const res = await new Promise((resolve, reject) => {
+    //     this.connection.query(sql, (err, res) => {
+    //         if(err) {
+    //             return reject(err);
+    //         }
+    //
+    //         return resolve(res);
+    //     });
+    // });
+    //
+    // this.connection.end();
+    //
+    // return res;
+  }
+}
+exports.MySQL = MySQL;

package/lib/makes/Plugin.d.ts

@@ -0,0 +1,13 @@
+import { Cli } from "@kearisp/cli";
+import { Controller } from "src/makes/Controller";
+declare class Plugin extends Controller {
+    protected certsDir: string;
+    protected dataDir: string;
+    protected pluginDir: string;
+    constructor(name: string);
+    install(cli: Cli): void;
+    certsPath(...paths: string[]): string;
+    dataPath(...paths: string[]): string;
+    pluginPath(...paths: string[]): string;
+}
+export { Plugin };

package/lib/makes/Plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Plugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _env = require("../env");
+var _Controller = require("./Controller");
+var _FS = require("./FS");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class Plugin extends _Controller.Controller {
+  constructor(name) {
+    super();
+    this.certsDir = Path.join(_env.DATA_DIR, "certs");
+    this.dataDir = Path.join(_env.DATA_DIR, "plugins", name);
+    this.pluginDir = Path.join(_env.PLUGINS_DIR, name);
+  }
+  install(cli) {
+    super.install(cli);
+    if (!_FS.FS.existsSync(this.certsDir)) {
+      _FS.FS.mkdirSync(this.certsDir, {
+        recursive: true
+      });
+    }
+    if (!_FS.FS.existsSync(this.dataDir)) {
+      _FS.FS.mkdirSync(this.dataDir, {
+        recursive: true
+      });
+    }
+  }
+  certsPath(...paths) {
+    return Path.join(this.certsDir, ...paths);
+  }
+  dataPath(...paths) {
+    return Path.join(this.dataDir, ...paths);
+  }
+  pluginPath(...paths) {
+    return Path.join(this.pluginDir, ...paths);
+  }
+}
+exports.Plugin = Plugin;

package/lib/makes/Repository.d.ts

@@ -0,0 +1,11 @@
+type Entity = {
+    id: number | string;
+};
+export declare class Repository<E extends Entity> {
+    create(data: Partial<E>): Promise<E>;
+    update(id: E["id"], record: Partial<E>): Promise<E>;
+    byId(id: E["id"]): Promise<E>;
+    search(params?: any): Promise<E[]>;
+    searchOne(params?: any): Promise<E>;
+}
+export {};

package/lib/makes/Repository.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Repository = void 0;
+class Repository {
+  async create(data) {
+    return null;
+  }
+  async update(id, record) {
+    return null;
+  }
+  async byId(id) {
+    return null;
+  }
+  async search(params) {
+    return [];
+  }
+  async searchOne(params) {
+    const [item] = await this.search(params);
+    return item;
+  }
+}
+exports.Repository = Repository;

package/lib/makes/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Controller";
+export * from "./Docker";
+export * from "./FS";
+export * from "./Logger";
+export * from "./Plugin";
+export * from "./Repository";

package/lib/makes/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Controller = require("./Controller");
+Object.keys(_Controller).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Controller[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Controller[key];
+    }
+  });
+});
+var _Docker = require("./Docker");
+Object.keys(_Docker).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Docker[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Docker[key];
+    }
+  });
+});
+var _FS = require("./FS");
+Object.keys(_FS).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _FS[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _FS[key];
+    }
+  });
+});
+var _Logger = require("./Logger");
+Object.keys(_Logger).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Logger[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Logger[key];
+    }
+  });
+});
+var _Plugin = require("./Plugin");
+Object.keys(_Plugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Plugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Plugin[key];
+    }
+  });
+});
+var _Repository = require("./Repository");
+Object.keys(_Repository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Repository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Repository[key];
+    }
+  });
+});

package/lib/models/Preset.d.ts

@@ -0,0 +1,19 @@
+import { PromptGroupOptions } from "src/utils";
+import { Project } from "./Project";
+export declare class Preset {
+    id: string;
+    name: string;
+    dockerfile?: string;
+    buildArgsOptions?: PromptGroupOptions<{
+        hash?: boolean;
+    }>;
+    envOptions?: PromptGroupOptions;
+    volumeOptions?: string[];
+    volumes?: string[];
+    constructor(data?: Preset);
+    getImageArgs(project: Project): import("../types").EnvConfig;
+    getImageName(buildArgs: {
+        [key: string]: string;
+    }): string;
+    static get(name: string): Promise<Preset>;
+}