Base Framework

Common errors

• TypeError: Base is not a constructor

  cause Attempting to instantiate Base (e.g., `new Base()`) when the import or require statement failed to correctly load the constructor, or when using an incorrect import style for a CommonJS module.
  fix Ensure you are using `const Base = require('base');` at the top of your file. Verify that 'base' is correctly installed in `node_modules`.

• ReferenceError: require is not defined

  cause This error typically occurs when trying to use `require` in a JavaScript module that is being treated as an ES module (e.g., in a file with `.mjs` extension or when `type: 'module'` is set in `package.json`).
  fix For the 'base' package, ensure your file is treated as a CommonJS module (e.g., `.js` extension without `type: 'module'` in `package.json`). If your project is ESM, you might consider dynamically importing it (`const Base = await import('base')`) but this is less common for this package.

Warnings

• breaking The 'base' package has been abandoned for over six years, with its last release (v3.0.0) dating back to 2018. This means it receives no further updates, bug fixes, or security patches. Using it in new projects may expose applications to unaddressed vulnerabilities or compatibility issues with newer Node.js versions and ecosystem libraries.
  Fix: For new projects, consider modern, actively maintained frameworks with similar modularity principles (e.g., Express.js, NestJS, Fastify). For existing projects, conduct a thorough security audit and explore migration paths or custom patching strategies.
• gotcha Due to the project's abandonment, a detailed migration guide for the major version jump from 0.x to 3.x is not readily available. Users upgrading from older versions may encounter undocumented breaking changes in API surface, plugin contracts, or expected behavior, requiring manual investigation of source code or trial-and-error.
  Fix: Thoroughly review the project's GitHub issues and commit history for clues about breaking changes. Implement comprehensive unit and integration tests when migrating to identify regressions early. If starting fresh, it's advised to avoid this package entirely.
• gotcha The package primarily uses CommonJS module syntax (`require`). Attempting to import it using ES module syntax (`import`) in an ES module context may lead to runtime errors (e.g., `require is not defined`) or require specific loader/bundler configurations, which might not be well-documented for this abandoned package.
  Fix: Always use `const Base = require('base');` when working with this package. If integrating into an ES module project, consider dynamic `import()` or transpilation if absolutely necessary, but prioritize CommonJS for direct usage.

Install

• npm install base npm
• yarn add base yarn
• pnpm add base pnpm

Imports

• Base
  wrong:

  import { Base } from 'base'

  correct:

  const Base = require('base')

  The 'base' package is primarily a CommonJS module, typical for packages of its era. ES module imports might lead to compatibility issues or require specific bundler configurations.

Quickstart

This quickstart demonstrates creating a Base application, utilizing its core methods for data management, defining non-enumerable properties, integrating a simple plugin, and inheriting from the Base class to build a custom application, all within a CommonJS environment.

const Base = require('base');

// 1. Create a new Base instance
const app = new Base();
console.log('Base application initialized.');

// 2. Use core methods: set, get, has
app.set('greeting', 'Hello, Base!');
console.log(`App greeting: ${app.get('greeting')}`);

if (app.has('greeting')) {
  console.log('The "greeting" property exists.');
}

// 3. Define a non-enumerable property
app.define('version', '3.0.0');
console.log(`App version (non-enumerable): ${app.version}`);
for (const key in app) {
  if (Object.prototype.hasOwnProperty.call(app, key)) {
    console.log(`Enumerable property: ${key}`);
  }
}

// 4. Demonstrate a simple plugin
function myLoggerPlugin(instance) {
  instance.log = function(message) {
    console.log(`[MyLoggerPlugin] ${message}`);
  };
  instance.log('Logger plugin activated.');
}

// Use the plugin
app.use(myLoggerPlugin);
app.log('This message is logged via the plugin.');

// 5. Extend Base to create a custom application class
function MyApp() {
  Base.call(this); // Call Base constructor
  this.name = 'My Custom App';
}
Base.extend(MyApp); // Inherit Base methods

const myAppInstance = new MyApp();
myAppInstance.set('owner', 'Registry AI');
console.log(`${myAppInstance.name} owner: ${myAppInstance.get('owner')}`);

// This snippet demonstrates initialization, basic data storage, non-enumerable properties,
// plugin integration, and inheritance, covering core functionalities of the Base framework.
// It is written in CommonJS, typical for the era of this package.