@scriptdb/system-modules 1.0.0

package/README.md

@@ -0,0 +1,397 @@
+# @scriptdb/system-modules
+
+System module resolver for the script database, providing built-in modules for creating, updating, removing, and saving code snippets.
+
+## Features
+
+- **Dynamic module loading**: Load system modules at runtime
+- **Code snippet management**: Create, update, remove, and save code snippets
+- **Module registry**: Maintain a registry of all available system modules
+- **Require-like functionality**: Access modules using a require-like API
+- **Import functionality**: Access modules using an import-like API
+
+## Installation
+
+```bash
+bun add @scriptdb/system-modules
+```
+
+## Quick Start
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+// Get the system modules context
+const context = await SystemModuleResolver();
+
+// Access the built-in modules
+const create = context.create;
+const update = context.update;
+const remove = context.remove;
+const save = context.save;
+
+// Create a new code snippet
+create('myDatabase', 'function myFunc() { return "Hello, World!"; }');
+
+// Update an existing function
+update('myDatabase', 'myFunc', () => { return "Updated function!"; });
+
+// Save entire code to a database
+save('myDatabase', 'export const PI = 3.14159;');
+
+// Remove a function
+remove('myDatabase', 'myFunc');
+```
+
+## API Reference
+
+### SystemModuleResolver()
+
+Resolves and loads all system modules, creating a context with built-in modules.
+
+```typescript
+await SystemModuleResolver(): Promise<Record<string, any>>
+```
+
+Returns a promise that resolves with a context object containing all system modules.
+
+### System Modules
+
+#### create(dbName, code)
+
+Creates a new code snippet in the specified database file.
+
+```typescript
+create(dbName: string, code: string | Function): void
+```
+
+- `dbName` (string): Name of the database file (without extension)
+- `code` (string | Function): Code content of the snippet
+
+#### update(dbName, fnName, code)
+
+Updates an existing code snippet in the specified database file.
+
+```typescript
+update(dbName: string, fnName: string, code: string | Function): string
+```
+
+- `dbName` (string): Name of the database file
+- `fnName` (string): Name of the function to update
+- `code` (string | Function): New code content
+
+Returns a string indicating the result of the operation.
+
+#### remove(dbName, fnName?)
+
+Removes a code snippet from the specified database file.
+
+```typescript
+remove(dbName: string, fnName?: string): string | boolean
+```
+
+- `dbName` (string): Name of the database file
+- `fnName` (string, optional): Name of the function to remove. If not provided, removes the entire file.
+
+Returns a string or boolean indicating the result of the operation.
+
+#### save(dbName, code)
+
+Saves code content to the specified database file, overwriting any existing content.
+
+```typescript
+save(dbName: string, code: string | Function | any): void
+```
+
+- `dbName` (string): Name of the database file
+- `code` (string | Function | any): Code content to save
+
+### Context Methods
+
+#### require(moduleName)
+
+Loads a system 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 system 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.
+
+## Examples
+
+### Creating and Managing Code Snippets
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+const context = await SystemModuleResolver();
+
+// Create a new function in a database
+context.create('math', `
+  function add(a: number, b: number): number {
+    return a + b;
+  }
+`);
+
+// Update an existing function
+context.update('math', 'add', (a: number, b: number) => {
+  console.log(`Adding ${a} and ${b}`);
+  return a + b;
+});
+
+// Add a new function to the same database
+context.create('math', `
+  function multiply(a: number, b: number): number {
+    return a * b;
+  }
+`);
+
+// Save a complete module
+context.save('utils', `
+  export const formatDate = (date: Date): string => {
+    return date.toISOString().split('T')[0];
+  }
+  
+  export const capitalize = (str: string): string => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+`);
+```
+
+### Using the Module Context
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+// Get the system modules context
+const context = await SystemModuleResolver();
+
+// Access modules directly
+const create = context.create;
+const update = context.update;
+
+// Create a new module
+create('userManagement', `
+  class UserManager {
+    private users: Array<{ id: number; name: string }> = [];
+    
+    addUser(name: string): void {
+      const id = this.users.length + 1;
+      this.users.push({ id, name });
+    }
+    
+    getUser(id: number): { id: number; name: string } | undefined {
+      return this.users.find(user => user.id === id);
+    }
+    
+    listUsers(): Array<{ id: number; name: string }> {
+      return [...this.users];
+    }
+  }
+  
+  export default UserManager;
+`);
+
+// Use the require-like functionality
+const userModule = context.require('userManagement');
+// In this case, userModule will contain the user management code
+```
+
+### Working with Different Module Types
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+const context = await SystemModuleResolver();
+
+// Create a class-based module
+context.create('database', `
+  class SimpleDatabase {
+    private data: Record<string, any> = {};
+    
+    set(key: string, value: any): void {
+      this.data[key] = value;
+    }
+    
+    get(key: string): any {
+      return this.data[key];
+    }
+    
+    has(key: string): boolean {
+      return key in this.data;
+    }
+    
+    delete(key: string): boolean {
+      if (this.has(key)) {
+        delete this.data[key];
+        return true;
+      }
+      return false;
+    }
+    
+    clear(): void {
+      this.data = {};
+    }
+  }
+  
+  export default SimpleDatabase;
+`);
+
+// Create a functional module
+context.create('stringUtils', `
+  export const reverse = (str: string): string => {
+    return str.split('').reverse().join('');
+  };
+  
+  export const truncate = (str: string, length: number): string => {
+    return str.length > length ? str.slice(0, length) + '...' : str;
+  };
+  
+  export const slugify = (str: string): string => {
+    return str
+      .toLowerCase()
+      .replace(/[^a-z0-9 -]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-');
+  };
+`);
+
+// Update a specific function in a module
+context.update('stringUtils', 'reverse', (str: string) => {
+  return Array.from(str).reverse().join('');
+});
+```
+
+### Managing Database Files
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+const context = await SystemModuleResolver();
+
+// Create a new database file with multiple functions
+context.save('api', `
+  import { fetch } from 'bun';
+  
+  // Function to make GET requests
+  export async function get(url: string): Promise<any> {
+    const response = await fetch(url);
+    return await response.json();
+  }
+  
+  // Function to make POST requests
+  export async function post(url: string, data: any): Promise<any> {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+    return await response.json();
+  }
+  
+  // Function to make PUT requests
+  export async function put(url: string, data: any): Promise<any> {
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+    return await response.json();
+  }
+  
+  // Function to make DELETE requests
+  export async function del(url: string): Promise<any> {
+    const response = await fetch(url, {
+      method: 'DELETE'
+    });
+    return await response.json();
+  }
+`);
+
+// Add a new function to the existing database
+context.create('api', `
+  export async function patch(url: string, data: any): Promise<any> {
+    const response = await fetch(url, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+    return await response.json();
+  }
+`);
+
+// Update an existing function
+context.update('api', 'get', async (url: string) => {
+  const response = await fetch(url);
+  return await response.json();
+});
+
+// Remove a specific function
+context.remove('api', 'del');
+
+// Remove the entire database file (after creating a backup)
+context.remove('api');
+```
+
+## Error Handling
+
+The System Module Resolver will throw an error if:
+
+- A module is not found when using require() or import()
+- There are issues with file operations
+
+```typescript
+import { SystemModuleResolver } from '@scriptdb/system-modules';
+
+try {
+  const context = await SystemModuleResolver();
+  
+  try {
+    const module = context.require('non-existent-module');
+  } catch (error) {
+    console.error('Module not found:', error.message);
+  }
+} catch (error) {
+  console.error('Failed to load system modules:', error.message);
+}
+```
+
+## File Structure
+
+System modules are stored in TypeScript files in the `./databases/system-modules` directory:
+
+```
+./databases/system-modules/
+├── myDatabase.ts     # Database file for code snippets
+├── math.ts           # Mathematical functions
+├── api.ts            # API-related functions
+└── utils.ts          # Utility functions
+```
+
+Each file can contain TypeScript code, including functions, classes, and exports.
+
+## Security Considerations
+
+- Validate code content before saving to prevent injection attacks
+- Consider implementing a sandboxed environment for executing code snippets
+- Limit file system access to prevent unauthorized access to sensitive files
+- Regularly backup your databases to prevent data loss
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,320 @@
+// src/modules/update.ts
+import path from "node:path";
+import fs from "node:fs";
+import * as os from "os";
+
+// src/utils/isIdentifier.ts
+function isIdentifier(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+
+// src/utils/valueToCode.ts
+function valueToCode(val, depth = 0) {
+  const indentUnit = "    ";
+  const indent = indentUnit.repeat(depth);
+  const indentInner = indentUnit.repeat(depth + 1);
+  if (val === null)
+    return "null";
+  const t = typeof val;
+  if (t === "string")
+    return JSON.stringify(val);
+  if (t === "number" || t === "boolean")
+    return String(val);
+  if (t === "function")
+    return val.toString();
+  if (Array.isArray(val)) {
+    if (val.length === 0)
+      return "[]";
+    const items = val.map((v) => valueToCode(v, depth + 1));
+    return `[
+` + items.map((it) => indentInner + it).join(`,
+`) + `
+` + indent + "]";
+  }
+  if (t === "object") {
+    const keys = Object.keys(val);
+    if (keys.length === 0)
+      return "{}";
+    const entries = keys.map((k) => {
+      const keyPart = isIdentifier(k) ? k : JSON.stringify(k);
+      const v = valueToCode(val[k], depth + 1);
+      return indentInner + keyPart + ": " + v;
+    });
+    return `{
+` + entries.join(`,
+`) + `
+` + indent + "}";
+  }
+  return String(val);
+}
+
+// src/modules/update.ts
+function update(dbName, fnName, code) {
+  const DIR = "databases";
+  const basePath = path.join(os.homedir(), ".scriptdb");
+  const baseDir = path.resolve(basePath, DIR);
+  const dbPath = path.join(baseDir, `${dbName}.ts`);
+  let src;
+  if (!fs.existsSync(dbPath)) {
+    try {
+      fs.writeFileSync(dbPath, "", "utf8");
+      return `Created new database file: ${dbPath}`;
+    } catch (e) {
+      return `Failed to create dbPath file: ${dbPath}`;
+    }
+  }
+  src = fs.readFileSync(dbPath, "utf8");
+  const originalSrc = src;
+  const escaped = fnName.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  const startRe = new RegExp(`function\\s+${escaped}\\s*\\(|\\bclass\\s+${escaped}\\b|\\b(?:const|let|var)\\s+${escaped}\\s*=\\s*(?:function\\b|class\\b|\\(|\\{|\\[)`, "m");
+  const startMatch = src.match(startRe);
+  let declKind = null;
+  if (startMatch) {
+    let startIdx = startMatch.index;
+    const snippet = src.slice(startIdx, startIdx + 80);
+    if (/^function\b/.test(snippet))
+      declKind = "functionDecl";
+    else if (/^class\b/.test(snippet))
+      declKind = "classDecl";
+    else if (/^\b(?:const|let|var)\b/.test(snippet))
+      declKind = "varAssign";
+  }
+  let newCode;
+  if (typeof code === "function") {
+    const fnStr = code.toString();
+    if (declKind === "functionDecl") {
+      if (/^function\s+\w+/.test(fnStr))
+        newCode = fnStr;
+      else
+        newCode = `function ${fnName}${fnStr.replace(/^function\s*\(/, "(")}`;
+    } else if (declKind === "classDecl") {
+      if (/^class\s+\w+/.test(fnStr))
+        newCode = fnStr;
+      else if (/^class\s*\{/.test(fnStr))
+        newCode = fnStr.replace(/^class\s*\{/, `class ${fnName} {`);
+      else
+        newCode = `const ${fnName} = ${fnStr};`;
+    } else {
+      newCode = `const ${fnName} = ${fnStr};`;
+    }
+  } else {
+    newCode = `const ${fnName} = ${valueToCode(code, 0)};`;
+  }
+  if (startMatch) {
+    const startIdx = startMatch.index;
+    const idxCurly = src.indexOf("{", startIdx);
+    const idxBracket = src.indexOf("[", startIdx);
+    let braceOpen = -1;
+    if (idxCurly === -1)
+      braceOpen = idxBracket;
+    else if (idxBracket === -1)
+      braceOpen = idxCurly;
+    else
+      braceOpen = Math.min(idxCurly, idxBracket);
+    if (braceOpen === -1) {
+      const exportRe = new RegExp(`export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`, "m");
+      if (exportRe.test(src)) {
+        src = src.replace(exportRe, `${newCode}
+
+export const ${fnName}: any = ${fnName};`);
+      } else {
+        src = src + `
+
+${newCode}
+
+export const ${fnName}: any = ${fnName};`;
+      }
+    } else {
+      const openingChar = src[braceOpen];
+      const closingChar = openingChar === "[" ? "]" : "}";
+      let i = braceOpen + 1;
+      let depth = 1;
+      const len = src.length;
+      while (i < len && depth > 0) {
+        const ch = src[i];
+        if (ch === openingChar)
+          depth++;
+        else if (ch === closingChar)
+          depth--;
+        i++;
+      }
+      let braceClose = i;
+      let endIdx = braceClose;
+      if (src.slice(braceClose, braceClose + 1) === ";")
+        endIdx = braceClose + 1;
+      const before = src.slice(0, startIdx);
+      const after = src.slice(endIdx);
+      src = before + newCode + after;
+    }
+  } else {
+    const exportRe = new RegExp(`export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`, "m");
+    if (exportRe.test(src)) {
+      src = src.replace(exportRe, `${newCode}
+
+export const ${fnName}: any = ${fnName};`);
+    } else {
+      src = src + `
+
+${newCode}
+
+export const ${fnName}: any = ${fnName};`;
+    }
+  }
+  fs.writeFileSync(dbPath, src, "utf8");
+  if (src === originalSrc) {
+    return `Saved ${fnName} to database ${dbName}.`;
+  } else {
+    return `Updated ${dbName} with ${fnName}.`;
+  }
+}
+
+// src/modules/remove.ts
+import path2 from "node:path";
+import fs2 from "node:fs";
+import * as os2 from "os";
+function remove(dbName, fnName) {
+  const DIR = "databases";
+  const basePath = path2.join(os2.homedir(), ".scriptdb");
+  const baseDir = path2.resolve(basePath, DIR);
+  const dbPath = path2.join(baseDir, `${dbName}.ts`);
+  if (!fs2.existsSync(dbPath))
+    return false;
+  if (!fnName) {
+    const bak2 = `${dbPath}.bak`;
+    try {
+      fs2.copyFileSync(dbPath, bak2);
+    } catch (e) {}
+    try {
+      fs2.unlinkSync(dbPath);
+      return "Removed successfully";
+    } catch (e) {
+      return "Removed failed";
+    }
+  }
+  const bak = `${dbPath}.bak`;
+  try {
+    fs2.copyFileSync(dbPath, bak);
+  } catch (e) {}
+  let src = fs2.readFileSync(dbPath, "utf8");
+  const escaped = fnName.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  const startRe = new RegExp(`function\\s+${escaped}\\s*\\(|\\bclass\\s+${escaped}\\b|\\b(?:const|let|var)\\s+${escaped}\\s*=\\s*(?:function\\b|class\\b|\\(|\\{|\\[)`, "m");
+  const startMatch = src.match(startRe);
+  if (startMatch) {
+    const startIdx = startMatch.index;
+    const len = src.length;
+    const idxCurly = src.indexOf("{", startIdx);
+    const idxBracket = src.indexOf("[", startIdx);
+    let braceOpen = -1;
+    if (idxCurly === -1)
+      braceOpen = idxBracket;
+    else if (idxBracket === -1)
+      braceOpen = idxCurly;
+    else
+      braceOpen = Math.min(idxCurly, idxBracket);
+    if (braceOpen !== -1) {
+      const openingChar = src[braceOpen];
+      const closingChar = openingChar === "[" ? "]" : "}";
+      let i = braceOpen + 1;
+      let depth = 1;
+      while (i < len && depth > 0) {
+        const ch = src[i];
+        if (ch === openingChar)
+          depth++;
+        else if (ch === closingChar)
+          depth--;
+        i++;
+      }
+      let braceClose = i;
+      let endIdx = braceClose;
+      if (src.slice(braceClose, braceClose + 1) === ";")
+        endIdx = braceClose + 1;
+      const before = src.slice(0, startIdx);
+      const after = src.slice(endIdx);
+      src = before + after;
+    } else {
+      const semi = src.indexOf(";", startIdx);
+      let endIdx = semi !== -1 ? semi + 1 : src.indexOf(`
+
+`, startIdx);
+      if (endIdx === -1)
+        endIdx = len;
+      src = src.slice(0, startIdx) + src.slice(endIdx);
+    }
+  }
+  const exportRe = new RegExp(`export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`, "g");
+  src = src.replace(exportRe, "");
+  src = src.replace(/\n{3,}/g, `
+
+`);
+  fs2.writeFileSync(dbPath, src, "utf8");
+  return `Removed ${fnName} from database ${dbName}.`;
+}
+
+// src/modules/create.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import * as os3 from "os";
+function create(dbName, code) {
+  const DIR = "databases";
+  const basePath = path3.join(os3.homedir(), ".scriptdb");
+  const baseDir = path3.resolve(basePath, DIR);
+  const dbPath = path3.join(baseDir, `${dbName}.ts`);
+  fs3.appendFileSync(dbPath, code.toString(), "utf8");
+}
+
+// src/modules/save.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os4 from "os";
+function save(dbName, code) {
+  const DIR = "databases";
+  const basePath = path4.join(os4.homedir(), ".scriptdb");
+  const baseDir = path4.resolve(basePath, DIR);
+  const dbPath = path4.join(baseDir, `${dbName}.ts`);
+  let fileContent = typeof code === "function" ? code.toString() : code;
+  fs4.writeFileSync(dbPath, fileContent, "utf8");
+}
+
+// src/index.ts
+var update2 = update;
+var remove2 = remove;
+var create2 = create;
+var save2 = save;
+async function SystemModuleResolver() {
+  const moduleRegistry = new Map;
+  moduleRegistry.set("update", update2);
+  moduleRegistry.set("remove", remove2);
+  moduleRegistry.set("create", create2);
+  moduleRegistry.set("save", save2);
+  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) {
+    context[name] = moduleExports.default || moduleExports;
+  }
+  return context;
+}
+var src_default = SystemModuleResolver;
+export {
+  update2 as update,
+  save2 as save,
+  remove2 as remove,
+  src_default as default,
+  create2 as create,
+  SystemModuleResolver
+};

package/package.json

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