@scriptdb/pmr 1.0.0

package/README.md

@@ -0,0 +1,181 @@
+# @scriptdb/pmr
+
+Plugins Module Resolver for the script database, providing dynamic plugin loading and resolution capabilities.
+
+## Features
+
+- **Dynamic plugin loading**: Load plugins from directories at runtime
+- **Module resolution**: Automatically resolve and import plugin modules
+- **Plugin discovery**: Discover plugins in specified directories
+- **Type-safe**: Full TypeScript support with type definitions
+
+## Installation
+
+```bash
+bun add @scriptdb/pmr
+```
+
+## Quick Start
+
+```typescript
+import { PluginModuleResolver } from '@scriptdb/pmr';
+
+// Resolve plugins from a directory
+const plugins = await PluginModuleResolver('./plugins');
+
+// Use the loaded plugins
+console.log(plugins);
+```
+
+## API Reference
+
+### PluginModuleResolver(basePath)
+
+Resolves and loads plugins from the specified directory.
+
+```typescript
+await PluginModuleResolver(basePath: string): Promise<any>
+```
+
+- `basePath` (string): The base directory path where plugins are located
+
+Returns a promise that resolves with the loaded plugins.
+
+## Plugin Structure
+
+To be compatible with the Plugin Module Resolver, your plugin directory should follow this structure:
+
+```
+plugins/
+├── index.ts          # Main plugin entry point
+└── plugin-files...   # Additional plugin files
+```
+
+The `index.ts` file should export a `plugins()` function:
+
+```typescript
+// plugins/index.ts
+export async function plugins() {
+  return {
+    // Plugin exports
+    hello: () => console.log('Hello from plugin!'),
+    add: (a: number, b: number) => a + b
+  };
+}
+```
+
+## Examples
+
+### Basic Plugin Loading
+
+```typescript
+import { PluginModuleResolver } from '@scriptdb/pmr';
+
+// Load plugins from the ./my-plugins directory
+const plugins = await PluginModuleResolver('./my-plugins');
+
+// Use plugin functions
+if (plugins.hello) {
+  plugins.hello(); // "Hello from plugin!"
+}
+
+if (plugins.add) {
+  const sum = plugins.add(5, 3); // 8
+  console.log(sum);
+}
+```
+
+### Plugin with Dependencies
+
+```typescript
+// plugins/calculator/index.ts
+export async function plugins() {
+  return {
+    add: (a: number, b: number) => a + b,
+    subtract: (a: number, b: number) => a - b,
+    multiply: (a: number, b: number) => a * b,
+    divide: (a: number, b: number) => a / b
+  };
+}
+
+// main.ts
+import { PluginModuleResolver } from '@scriptdb/pmr';
+
+const calc = await PluginModuleResolver('./plugins/calculator');
+
+console.log(calc.add(5, 3));       // 8
+console.log(calc.subtract(5, 3));  // 2
+console.log(calc.multiply(5, 3));  // 15
+console.log(calc.divide(15, 3));   // 5
+```
+
+### Advanced Plugin with Configuration
+
+```typescript
+// plugins/database/index.ts
+interface DatabaseConfig {
+  host: string;
+  port: number;
+  name: string;
+}
+
+let config: DatabaseConfig | null = null;
+
+export async function plugins() {
+  return {
+    configure: (options: DatabaseConfig) => {
+      config = options;
+    },
+    connect: () => {
+      if (!config) {
+        throw new Error('Database not configured. Call configure() first.');
+      }
+      // Database connection logic here
+      return `Connected to ${config.host}:${config.port}/${config.name}`;
+    }
+  };
+}
+
+// main.ts
+import { PluginModuleResolver } from '@scriptdb/pmr';
+
+const db = await PluginModuleResolver('./plugins/database');
+
+db.configure({
+  host: 'localhost',
+  port: 5432,
+  name: 'mydb'
+});
+
+console.log(db.connect()); // "Connected to localhost:5432/mydb"
+```
+
+## Error Handling
+
+The Plugin Module Resolver will throw an error if:
+
+- The specified directory doesn't exist
+- The index.ts file is not found
+- The plugins() function is not exported
+- There are syntax errors in the plugin code
+
+```typescript
+import { PluginModuleResolver } from '@scriptdb/pmr';
+
+try {
+  const plugins = await PluginModuleResolver('./non-existent-directory');
+} catch (error) {
+  console.error('Failed to load plugins:', error.message);
+}
+```
+
+## Security Considerations
+
+- Only load plugins from trusted sources
+- Validate plugin functionality before use
+- Consider implementing a sandboxed environment for untrusted plugins
+- Limit plugin access to sensitive resources
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,12 @@
+// src/index.ts
+import path from "node:path";
+async function PluginModuleResolver(baseBase) {
+  const DIR = baseBase;
+  const res = await import(path.resolve(path.join(DIR, "index.ts")));
+  return await res.plugins();
+}
+var src_default = PluginModuleResolver;
+export {
+  src_default as default,
+  PluginModuleResolver
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@scriptdb/pmr",
+  "version": "1.0.0",
+  "description": "Plugins module resolver for script database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --splitting",
+    "build:cjs": "bun build src/index.ts --outdir dist --target node --format cjs --outfile dist/index.js",
+    "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
+    "build:all": "bun run build && bun run build:cjs && bun run build:types",
+    "test": "bun test",
+    "lint": "bun run lint:src",
+    "lint:src": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.2",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "bun-types": "latest",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}