@serenityjs/plugins 0.1.0-beta.10

package/README.md

@@ -0,0 +1,2 @@
+# Plugins
+

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { Logger } from '@serenityjs/logger';
+
+/**
+ * Represents a base plugin that can be loaded into the Serenity server.
+ */
+declare abstract class BasePlugin<T = unknown> {
+    /**
+     * The serenity instance.
+     */
+    readonly serenity: T;
+    /**
+     * The logger instance.
+     */
+    readonly logger: Logger;
+    /**
+     * Constructs a new base plugin instance.
+     *
+     * @param serenity - The serenity instance.
+     * @param logger - The logger instance.
+     */
+    constructor(serenity: T, logger: Logger);
+    /**
+     * Called when the plugin is started.
+     */
+    startup(): void;
+    /**
+     * Called when the plugin is stopped.
+     */
+    shutdown(): void;
+}
+
+interface Plugin {
+    instance: BasePlugin;
+    package: Record<string, unknown>;
+    plugin: unknown;
+}
+interface tsconfig {
+    compilerOptions: {
+        outDir: string;
+    };
+}
+declare class Plugins<T> {
+    /**
+     * The serenity instance.
+     */
+    protected readonly serenity: T;
+    /**
+     * The logger instance.
+     */
+    readonly logger: Logger;
+    /**
+     * The path to the plugins folder.
+     */
+    readonly path: string;
+    /**
+     * The plugins map.
+     */
+    readonly plugins: Map<string, Plugin>;
+    /**
+     * Constructs a new plugins instance.
+     *
+     * @param serenity - The serenity instance.
+     */
+    constructor(serenity: T, path: string, enabled?: boolean);
+    loadNew(): Promise<void>;
+    validatePackage(path: string, pack: Record<string, unknown>): boolean;
+    validateTsconfig(path: string, tsconfig: tsconfig): boolean;
+}
+
+export { BasePlugin, Plugins };

package/dist/index.js

@@ -0,0 +1,240 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BasePlugin: () => BasePlugin,
+  Plugins: () => Plugins
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/base.ts
+var BasePlugin = class {
+  /**
+   * The serenity instance.
+   */
+  serenity;
+  /**
+   * The logger instance.
+   */
+  logger;
+  /**
+   * Constructs a new base plugin instance.
+   *
+   * @param serenity - The serenity instance.
+   * @param logger - The logger instance.
+   */
+  constructor(serenity, logger) {
+    this.serenity = serenity;
+    this.logger = logger;
+    this.startup();
+  }
+  /**
+   * Called when the plugin is started.
+   */
+  startup() {
+  }
+  /**
+   * Called when the plugin is stopped.
+   */
+  shutdown() {
+  }
+};
+
+// src/plugins.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_process = __toESM(require("process"));
+var import_logger = require("@serenityjs/logger");
+var Plugins = class {
+  /**
+   * The serenity instance.
+   */
+  serenity;
+  /**
+   * The logger instance.
+   */
+  logger;
+  /**
+   * The path to the plugins folder.
+   */
+  path;
+  /**
+   * The plugins map.
+   */
+  plugins;
+  /**
+   * Constructs a new plugins instance.
+   *
+   * @param serenity - The serenity instance.
+   */
+  constructor(serenity, path, enabled = true) {
+    this.serenity = serenity;
+    this.logger = new import_logger.Logger("Plugins", import_logger.LoggerColors.CyanBright);
+    this.path = (0, import_node_path.resolve)(import_node_process.default.cwd(), path);
+    this.plugins = /* @__PURE__ */ new Map();
+    if (enabled) {
+      if (!(0, import_node_fs.existsSync)(this.path)) {
+        (0, import_node_fs.mkdirSync)(this.path);
+        this.logger.success(`Created plugins folder at "${this.path}"`);
+      }
+      void this.loadNew();
+    }
+  }
+  async loadNew() {
+    const files = (0, import_node_fs.readdirSync)(this.path, { withFileTypes: true });
+    for (const file of files) {
+      if (!file.isDirectory())
+        continue;
+      const files2 = (0, import_node_fs.readdirSync)((0, import_node_path.resolve)(file.path, file.name), {
+        withFileTypes: true
+      });
+      const packExsist = files2.find((file2) => file2.name === "package.json");
+      if (!packExsist) {
+        this.logger.error(
+          `Plugin "${file.name}" does not contain a package.json file.`
+        );
+        continue;
+      }
+      const pack = JSON.parse(
+        (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(packExsist.path, packExsist.name), "utf8")
+      );
+      if (!this.validatePackage(file.name, pack))
+        continue;
+      const needModules = (0, import_node_fs.existsSync)(
+        (0, import_node_path.resolve)(file.path, file.name, "node_modules")
+      );
+      if (!needModules) {
+        try {
+          (0, import_node_child_process.execSync)("npm install", { cwd: (0, import_node_path.resolve)(file.path, file.name) });
+        } catch (reason) {
+          this.logger.error(
+            `Failed to install node_modules for plugin "${file.name}".`,
+            reason
+          );
+          continue;
+        }
+        this.logger.success(
+          `Installed node_modules for plugin "${file.name}".`
+        );
+      }
+      const typescript = files2.find((file2) => file2.name === "tsconfig.json");
+      const tsconfig = typescript ? JSON.parse(
+        (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(typescript.path, typescript.name), "utf8")
+      ) : null;
+      if (typescript && !this.validateTsconfig(file.name, tsconfig))
+        continue;
+      const needToCompile = Boolean(
+        typescript && !(0, import_node_fs.existsSync)(
+          (0, import_node_path.resolve)(file.path, file.name, tsconfig.compilerOptions.outDir)
+        ) || Boolean(pack?.development ?? false) === true
+      );
+      if (needToCompile) {
+        try {
+          if (pack?.scripts?.build) {
+            (0, import_node_child_process.execSync)("npm run build", { cwd: (0, import_node_path.resolve)(file.path, file.name) });
+          } else {
+            (0, import_node_child_process.execSync)("tsc", { cwd: (0, import_node_path.resolve)(file.path, file.name) });
+          }
+          this.logger.success(`Compiled plugin "${file.name}".`);
+        } catch (reason) {
+          this.logger.error(`Failed to compile plugin "${file.name}".`, reason);
+          continue;
+        }
+      }
+      try {
+        const plugin = await import(`file://${(0, import_node_path.resolve)(file.path, file.name, pack.main)}`);
+        if (!plugin.default)
+          continue;
+        const instance = new plugin.default(
+          this.serenity,
+          new import_logger.Logger(`${file.name}@${pack.version}`, import_logger.LoggerColors.Blue)
+        );
+        this.plugins.set(file.name, { instance, package: pack, plugin });
+      } catch (reason) {
+        this.logger.error(`Failed to import plugin "${file.name}".`, reason);
+        continue;
+      }
+    }
+  }
+  validatePackage(path, pack) {
+    if (!pack?.name) {
+      this.logger.error(
+        `Plugin package.json "${path}" does not contain a "name" property.`
+      );
+      return false;
+    }
+    if (!pack?.version) {
+      this.logger.error(
+        `Plugin package.json "${path}" does not contain a "version" property.`
+      );
+      return false;
+    }
+    if (!pack?.type) {
+      this.logger.error(
+        `Plugin package.json "${path}" does not contain a "type" property.`
+      );
+      return false;
+    } else if (pack.type !== "module") {
+      this.logger.error(
+        `Plugin package.json "${path}" type is not set to "module".`
+      );
+      return false;
+    }
+    if (!pack?.main) {
+      this.logger.error(
+        `Plugin package.json "${path}" does not contain a "main" property.`
+      );
+      return false;
+    }
+    return true;
+  }
+  validateTsconfig(path, tsconfig) {
+    if (!tsconfig?.compilerOptions) {
+      this.logger.error(
+        `Plugin tsconfig.json "${path}" does not contain a "compilerOptions" property.`
+      );
+      return false;
+    }
+    if (!tsconfig?.compilerOptions?.outDir) {
+      this.logger.error(
+        `Plugin tsconfig.json "${path}" does not contain a "outDir" property.`
+      );
+      return false;
+    }
+    return true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BasePlugin,
+  Plugins
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@serenityjs/plugins",
+	"version": "0.1.0-beta.10",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"repository": "https://github.com/SerenityJS/serenity",
+	"files": [
+		"dist/**"
+	],
+	"scripts": {
+		"build": "tsup",
+		"watch": "tsup --watch",
+		"lint": "eslint src/",
+		"typecheck": "tsc --noEmit",
+		"test": "jest"
+	},
+	"jest": {
+		"preset": "@serenityjs/jest-presets/jest/node"
+	},
+	"devDependencies": {
+		"@serenityjs/eslint-config": "0.1.0-beta.10",
+		"@serenityjs/jest-presets": "0.1.0-beta.10",
+		"@serenityjs/typescript-config": "0.1.0-beta.10",
+		"@types/jest": "^29.5.12",
+		"@types/node": "^20.11.24",
+		"jest": "^29.7.0",
+		"tsup": "^8.0.2",
+		"typescript": "^5.4.2"
+	},
+	"dependencies": {
+		"@serenityjs/logger": "0.1.0-beta.10"
+	}
+}