@scriptdb/dmr 1.0.0

package/README.md

@@ -0,0 +1,245 @@
+# @scriptdb/dmr
+
+Database Module Resolver for the script database, providing dynamic module loading and resolution capabilities for database-related modules.
+
+## Features
+
+- **Dynamic module loading**: Load modules from directories at runtime
+- **Module registry**: Maintain a registry of all loaded modules
+- **Require-like functionality**: Access modules using a require-like API
+- **Import functionality**: Access modules using an import-like API
+- **Context creation**: Create a context with all loaded modules
+
+## Installation
+
+```bash
+bun add @scriptdb/dmr
+```
+
+## Quick Start
+
+```typescript
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+// Resolve modules from a directory
+const context = await DatabaseModuleResolver('./database-modules');
+
+// Access modules directly from the context
+const userModule = context.user;
+const authModule = context.auth;
+
+// Or use the require-like functionality
+const utils = context.require('utils');
+```
+
+## API Reference
+
+### DatabaseModuleResolver(basePath)
+
+Resolves and loads modules from the specified directory, creating a context with all loaded modules.
+
+```typescript
+await DatabaseModuleResolver(basePath: string): Promise<Record<string, any>>
+```
+
+- `basePath` (string): The base directory path where modules are located
+
+Returns a promise that resolves with a context object containing all loaded modules.
+
+### Context Methods
+
+#### require(moduleName)
+
+Loads a module by name.
+
+```typescript
+context.require(moduleName: string): any
+```
+
+- `moduleName` (string): The name of the module to load
+
+Returns the module's default export if available, otherwise the module itself.
+
+#### import(moduleName)
+
+Asynchronously loads a module by name.
+
+```typescript
+context.import(moduleName: string): Promise<{ default: any }>
+```
+
+- `moduleName` (string): The name of the module to load
+
+Returns a promise that resolves with an object containing the module's default export.
+
+## Module Structure
+
+To be compatible with the Database Module Resolver, your modules should be TypeScript files (.ts) in the specified directory:
+
+```
+database-modules/
+├── user.ts          # User module
+├── auth.ts          # Authentication module
+├── utils.ts         # Utility module
+└── index.ts         # Optional main entry point
+```
+
+Each module can export functions, classes, or objects:
+
+```typescript
+// database-modules/user.ts
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+export class UserService {
+  async getUser(id: number): Promise<User> {
+    // Implementation here
+    return { id, name: 'John Doe', email: 'john@example.com' };
+  }
+}
+
+export default new UserService();
+```
+
+## Examples
+
+### Basic Module Loading
+
+```typescript
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+// Load modules from the ./database-modules directory
+const context = await DatabaseModuleResolver('./database-modules');
+
+// Access modules directly
+const userModule = context.user;
+if (userModule && userModule.getUser) {
+  const user = await userModule.getUser(1);
+  console.log(user);
+}
+
+// Use the require-like functionality
+const utils = context.require('utils');
+if (utils && utils.formatDate) {
+  const formattedDate = utils.formatDate(new Date());
+  console.log(formattedDate);
+}
+```
+
+### Module with Default Export
+
+```typescript
+// database-modules/database.ts
+export class Database {
+  private connection: any;
+
+  constructor() {
+    // Initialize connection
+  }
+
+  async query(sql: string, params?: any[]) {
+    // Execute query
+    return { sql, params, results: [] };
+  }
+
+  async close() {
+    // Close connection
+  }
+}
+
+export default new Database();
+
+// main.ts
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+const context = await DatabaseModuleResolver('./database-modules');
+
+// Access the default export
+const db = context.database;
+const result = await db.query('SELECT * FROM users');
+console.log(result);
+```
+
+### Using the Import Functionality
+
+```typescript
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+const context = await DatabaseModuleResolver('./database-modules');
+
+// Use the import functionality to load a module
+const module = await context.import('auth');
+const authService = module.default;
+
+if (authService && authService.authenticate) {
+  const result = await authService.authenticate('username', 'password');
+  console.log(result);
+}
+```
+
+### Advanced Usage with Type Safety
+
+```typescript
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+interface ModuleContext {
+  user?: {
+    getUser: (id: number) => Promise<{ id: number; name: string }>;
+  };
+  auth?: {
+    authenticate: (username: string, password: string) => Promise<boolean>;
+  };
+  utils?: {
+    formatDate: (date: Date) => string;
+  };
+  require: (moduleName: string) => any;
+  import: (moduleName: string) => Promise<{ default: any }>;
+}
+
+const context = await DatabaseModuleResolver('./database-modules') as ModuleContext;
+
+if (context.user && context.auth) {
+  const user = await context.user.getUser(1);
+  const isAuthenticated = await context.auth.authenticate('username', 'password');
+  
+  console.log(`User: ${user.name}, Authenticated: ${isAuthenticated}`);
+}
+```
+
+## Error Handling
+
+The Database Module Resolver will throw an error if:
+
+- The specified directory doesn't exist
+- There are syntax errors in the module code
+- A module is not found when using require() or import()
+
+```typescript
+import { DatabaseModuleResolver } from '@scriptdb/dmr';
+
+try {
+  const context = await DatabaseModuleResolver('./non-existent-directory');
+} catch (error) {
+  console.error('Failed to load modules:', error.message);
+}
+
+try {
+  const module = context.require('non-existent-module');
+} catch (error) {
+  console.error('Module not found:', error.message);
+}
+```
+
+## Security Considerations
+
+- Only load modules from trusted sources
+- Validate module functionality before use
+- Consider implementing a sandboxed environment for untrusted modules
+- Limit module access to sensitive resources
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,45 @@
+// src/index.ts
+import fs from "node:fs";
+import path from "node:path";
+async function DatabaseModuleResolver(baseBase) {
+  const DIR = baseBase;
+  const moduleRegistry = new Map;
+  const files = fs.readdirSync(DIR).filter((f) => f.endsWith(".ts")).map((f) => path.join(DIR, f));
+  for (const filePath of files) {
+    const moduleName = path.basename(filePath, ".ts");
+    moduleRegistry.set(moduleName, await import(path.resolve(filePath)));
+  }
+  const context = {
+    require: (moduleName) => {
+      const module = moduleRegistry.get(moduleName);
+      if (!module) {
+        throw new Error(`Module '${moduleName}' not found`);
+      }
+      return module.default || module;
+    },
+    import: async (moduleName) => {
+      const module = moduleRegistry.get(moduleName);
+      if (!module) {
+        throw new Error(`Module '${moduleName}' not found`);
+      }
+      return {
+        default: module.default || module
+      };
+    }
+  };
+  for (const [name, moduleExports] of moduleRegistry) {
+    if (moduleExports.default) {
+      context[name] = moduleExports.default;
+    } else if (moduleExports[name]) {
+      context[name] = moduleExports[name];
+    } else {
+      context[name] = moduleExports;
+    }
+  }
+  return context;
+}
+var src_default = DatabaseModuleResolver;
+export {
+  src_default as default,
+  DatabaseModuleResolver
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@scriptdb/dmr",
+  "version": "1.0.0",
+  "description": "DMR 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"
+  }
+}