A Teq application is first a Node.js application and then a modular application composed of Teq plugins, which are npm modules. The platform core has three jobs: start the application and its console commands, discover and attach plugins, and establish the foundational architecture.

Bootstrap

The application entry point is bin/tequila.mjs. It finds the application root, loads the DI container, maps core sources, creates the bootstrap configuration, obtains TeqFw_Core_Back_App$, initializes it, and runs it. The script belongs to the application but is intentionally almost identical from one Teq application to another.

import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import teq from '@teqfw/core';

const root = join(dirname(fileURLToPath(import.meta.url)), '..');
teq({ path: root }).catch(console.error);

Different behaviour comes from the installed plugins and the commands they contribute, not from rewriting the launcher.

Core application lifecycle

During initialization, TeqFw_Core_Back_App:

• initializes logging;
• loads local configuration, such as database connection settings;
• scans the application filesystem and creates the plugin registry;
• adds namespaces discovered in plugins to the DI container;
• collects CLI commands from those plugins.

During execution it runs the requested command — commonly a web server. With no command, it prints the available commands. The application also exposes stop() so a command can close resources such as database connections in an orderly way.

Logger and configuration

The original core design exposed a common logger abstraction that could work on backend or frontend and route records to transports such as console, file, database, or remote server. Local backend configuration is read from a JSON file such as cfg/local.json and injected into the objects that need it. Secrets should remain in an ignored local configuration or a secure deployment environment, never in a package descriptor.

Plugin scanner

A Teq plugin is an npm package with a teqfw.json descriptor in its root. At minimum it declares a namespace and source directory:

{
  "autoload": {
    "ns": "Vendor_Project_Plugin",
    "path": "./src"
  }
}

The plugin scanner walks node_modules, finds descriptors, records plugin packages, and adds namespace-to-filesystem mappings to DI. Other parts of the application access plugin descriptors through this registry instead of rescanning the filesystem.

Commands

The core application is effectively a wrapper around commander. Plugin descriptors list module identifiers that produce command DTOs:

{ "commands": ["TeqFw_Core_Back_Cli_Version"] }

A command DTO provides an action, description, name and optional realm. The realm prefixes commands from one plugin, so app plus clean becomes app-clean.

const command = await container.get(`${factoryName}$`);
const fullName = command.realm ? `${command.realm}-${command.name}` : command.name;
commander.command(fullName).description(command.desc).action(command.action);

Summary

The Core plugin turns a collection of npm modules into a runnable Teq application. It discovers plugins, registers their namespaces, initializes logging and local configuration, collects their commands, and executes the selected command through DI. This keeps the launcher stable while applications grow by composing plugins.