Add support loading package plugins

Author: The2Alert

.gitignore

@@ -1,3 +1,5 @@
 /node_modules
 /dist/**/*.js
+!/dist/install.js
+!/dist/logger.js
 /server

dist/install.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = exports.downloadArchive = void 0;
+const promises_1 = require("fs/promises");
+const download = require("download");
+const extract = require("extract-zip");
+const path_1 = require("path");
+const logger_1 = require("./logger");
+function downloadArchive() {
+    if (process.platform === "win32")
+        return download("https://github.com/dev2alert/node-samp/releases/download/1.0.0/server-win32.zip");
+    else
+        return download("https://github.com/dev2alert/node-samp/releases/download/1.0.0/server-linux.zip");
+}
+exports.downloadArchive = downloadArchive;
+async function install() {
+    (0, logger_1.log)("Downloading...");
+    const tmpPath = (0, path_1.join)(__dirname, "../tmp");
+    const archivePath = (0, path_1.join)(tmpPath, "./server.zip");
+    const serverPath = (0, path_1.join)(__dirname, "../server");
+    await (0, promises_1.mkdir)(tmpPath);
+    const archive = await downloadArchive();
+    await (0, promises_1.writeFile)(archivePath, archive);
+    (0, logger_1.log)("Extracting...");
+    await extract(archivePath, { dir: serverPath });
+    await (0, promises_1.unlink)(archivePath);
+    await (0, promises_1.rmdir)(tmpPath);
+    if (process.platform !== "win32") {
+        await (0, promises_1.chmod)((0, path_1.join)(serverPath, "./samp03svr"), 0o777);
+        await (0, promises_1.chmod)((0, path_1.join)(serverPath, "./announce"), 0o777);
+    }
+    (0, logger_1.log)("Installed.");
+}
+exports.install = install;
+install();

dist/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.error = exports.log = void 0;
+const chalk = require("chalk");
+function log(content) {
+    return console.log(chalk.yellow.bold("[NodeSamp]"), content);
+}
+exports.log = log;
+function error(error) {
+    return console.log(chalk.yellow.bold("[NodeSamp]") + chalk.red.bold("[Error]"), error.message);
+}
+exports.error = error;
+var config;
+(function (config) {
+    function error(error) {
+        return console.log(chalk.yellow.bold("[Config]") + chalk.red.bold("[Error]"), error.message);
+    }
+    config.error = error;
+})(config = exports.config || (exports.config = {}));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sa-mp/cli",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Command Line Interface (CLI) for NodeSamp.",
   "keywords": [
     "nodesamp",
@@ -19,9 +19,8 @@
   "scripts": {
     "start": "cross-env NODE_ENV=production node . -h",
     "compile": "tsc",
-    "dev": "cross-env NODE_ENV=development tsc-watch --onSuccess \"node . ../starter\"",
-    "postinstall": "cross-env NODE_ENV=production node ./dist/install.js",
-    "install-dev": "cross-env NODE_ENV=development tsc-watch --onSuccess \"node ./dist/install.js\""
+    "dev": "cross-env NODE_ENV=development tsc-watch --onSuccess \"node . -h\"",
+    "postinstall": "cross-env NODE_ENV=production node ./dist/install.js"
   },
   "author": "dev2alert",
   "license": "MIT",

src/actions/root/config-params.ts

@@ -1,6 +1,5 @@
-import {Type} from "class-transformer";
-import {IsArray, IsBoolean, IsInt, IsOptional, IsString, IsUrl, ValidateNested} from "class-validator";
-import {PluginParams} from "./plugin-params";
+import {IsBoolean, IsInt, IsOptional, IsString, IsUrl} from "class-validator";
+import {IsPluginParams, PluginParams} from "./plugin-params";
 
 export class ConfigParams {
     @IsOptional()
@@ -36,14 +35,12 @@ export class ConfigParams {
     public rconPassword?: string;
 
     @IsOptional()
-    @IsArray()
-    @ValidateNested({each: true})
-    @Type(() => PluginParams)
-    public plugins?: PluginParams[];
+    @IsPluginParams()
+    public plugins: (string | PluginParams)[] = [];
 
     @IsOptional()
     @IsString()
-    public pluginsPath: string = ".";
+    public pluginsPath: string = "./plugins";
 
     @IsOptional()
     @IsString()

src/actions/root/config.ts

@@ -34,7 +34,7 @@ export class Config {
         return Config.parsers[info.mimeType] ?? null;
     }
 
-    private static throwValidationErrors(errors: ValidationError[]): void {
+    public static throwValidationErrors(errors: ValidationError[]): void {
         for(const error of errors) {
             if(error.constraints) {
                 for(const message of Object.values(error.constraints))

src/actions/root/index.ts

@@ -31,9 +31,7 @@ export class Root {
             } else this.config = await Config.get(this, ConfigPathTypes.PACKAGE, this.getPackageFullPath());
             const params: ConfigParams = this.config.getParams();
             await removePlugins(this);
-            if(params.plugins)
-                this.plugins = await createPlugins(this, params.plugins);
-            else this.plugins = [];
+            this.plugins = await createPlugins(this, params.plugins);
             await this.config.createServerConfig();
             await this.createPluginConfig();
             const serverPath: string = this.getServerPath();

src/actions/root/package-params.ts

@@ -0,0 +1,27 @@
+import {Type} from "class-transformer";
+import {IsOptional, IsString, ValidateNested} from "class-validator";
+import {IsPluginParams, PluginParams} from "./plugin-params";
+
+export class PackageConfigSampParams {
+    @IsOptional()
+    @IsPluginParams()
+    public plugins: (string | PluginParams)[] = [];
+
+    @IsOptional()
+    @IsString()
+    public pluginsPath: string = "./plugins";
+}
+
+export class PackageConfigParams {
+    @IsOptional()
+    @ValidateNested()
+    @Type(() => PackageConfigSampParams)
+    public samp: PackageConfigSampParams = new PackageConfigSampParams;
+}
+
+export class PackageParams {
+    @IsOptional()
+    @ValidateNested()
+    @Type(() => PackageConfigParams)
+    public config: PackageConfigParams = new PackageConfigParams;
+}

src/actions/root/plugin-params.ts

@@ -1,9 +1,21 @@
-import {IsString} from "class-validator";
+import {Validate, ValidationArguments, ValidatorConstraint, ValidatorConstraintInterface} from "class-validator";
 
-export class PluginParams {
-    @IsString()
-    public platform: string;
+export interface PluginParams {
+    platform: string;
+    path: string;
+}
 
-    @IsString()
-    public path: string;
+@ValidatorConstraint({name: "isPluginParams", async: false})
+export class PluginParamsValidator implements ValidatorConstraintInterface {
+    public validate(value: unknown): boolean {
+        return value instanceof Array && value.every((value) => typeof value === "string" || (typeof value === "object" && typeof value.platform === "string" && typeof value.path === "string"));
+    }
+
+    public defaultMessage({property}: ValidationArguments): string {
+        return `each value in ${property} must be an {platform: string, path: string} or string`;
+    }
+}
+
+export function IsPluginParams(): PropertyDecorator {
+    return Validate(PluginParamsValidator);
 }

src/actions/root/plugin.ts

@@ -1,19 +1,22 @@
+import {plainToClass} from "class-transformer";
+import {validate} from "class-validator";
 import * as fs from "fs";
-import {access, unlink, link, readdir} from "fs/promises";
+import {access, unlink, link, readdir, readFile} from "fs/promises";
 import {join, parse, basename} from "path";
 import {Root} from ".";
 import {Config} from "./config";
 import {ConfigParams} from "./config-params";
+import {PackageParams} from "./package-params";
 import {PluginParams} from "./plugin-params";
 
 export class Plugin {
-    public static async create(root: Root, params: PluginParams): Promise<Plugin> {
-        const plugin = new Plugin(root, params);
+    public static async create(root: Root, pluginsPath: string, params: PluginParams): Promise<Plugin> {
+        const plugin = new Plugin(root, pluginsPath, params);
         await plugin.create();
         return plugin;
     }
 
-    constructor(public readonly root: Root, public readonly params: PluginParams) {}
+    constructor(public readonly root: Root, public readonly pluginsPath: string, public readonly params: PluginParams) {}
 
     public name?: string;
     public path?: string;
@@ -26,11 +29,7 @@ export class Plugin {
     public async create(): Promise<void> {
         if(!this.isSupported())
             return;
-        const config: Config | null = this.root.getConfig();
-        if(config === null)
-            return;
-        const configParams: ConfigParams = config.getParams();
-        this.path = join(this.root.getPackageFullPath(), configParams.pluginsPath, this.params.path);
+        this.path = join(this.pluginsPath, this.params.path);
         this.name = parse(this.getPath()).name;
         try {
             await access(this.getPath(), fs.constants.F_OK);
@@ -64,9 +63,42 @@ export async function removePlugins(root: Root): Promise<void> {
     }
 }
 
-export async function createPlugins(root: Root, paramsList: PluginParams[]): Promise<Plugin[]> {
+export async function createPlugins(root: Root, plugins: (string | PluginParams)[]): Promise<Plugin[]> {
+    const result: Plugin[] = [];
+    for(const params of plugins) {
+        if(typeof params === "string")
+            result.push(...await createPackagePlugins(root, params));
+        else {
+            const config: Config | null = root.getConfig();
+            if(config === null)
+                break;
+            const configParams: ConfigParams = config.getParams();
+            const pluginsPath: string = join(root.getPackageFullPath(), configParams.pluginsPath);
+            result.push(await Plugin.create(root, pluginsPath, params));
+        }
+    }
+    return result;
+}
+
+export async function createPackagePlugins(root: Root, packageName: string): Promise<Plugin[]> {
+    const packagePath: string = join(root.getPackageFullPath(), "./node_modules", packageName);
+    let packageContent: unknown;
+    try {
+        packageContent = JSON.parse(String(await readFile(join(packagePath, "./package.json"))));
+    } catch(error) {
+        throw new Error(`Package ${JSON.stringify(packageName)} not found.`);
+    }
+    const packageParams: PackageParams = plainToClass(PackageParams, packageContent);
+    Config.throwValidationErrors(await validate(packageParams));
+    const plugins: (string | PluginParams)[] = packageParams.config.samp.plugins;
     const result: Plugin[] = [];
-    for(const params of paramsList)
-        result.push(await Plugin.create(root, params));
+    for(const params of plugins) {
+        if(typeof params === "string")
+            result.push(...await createPackagePlugins(root, params));
+        else {
+            const pluginsPath: string = join(packagePath, packageParams.config.samp.pluginsPath);
+            result.push(await Plugin.create(root, pluginsPath, params));
+        }
+    }
     return result;
 }