@solidxai/core 0.0.2

package/src/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { CommandFactory } from "nest-commander";
+import { SolidCoreCliModule } from "./solid-core-cli.module";
+
+async function bootstrap() {
+
+    // const app = await NestFactory.create(appModule);
+
+    // Create an instance of the application, capture the application context so we can inject it into a service in itself.
+    // @ts-ignore
+    const app = await CommandFactory.createWithoutRunning(SolidCoreCliModule, ['debug', 'error', 'fatal', 'log', 'verbose', 'warn']);
+    // const app = await CommandFactory.createWithoutRunning(AppModule, ['debug', 'error', 'fatal', 'log', 'verbose', 'warn']);
+    // const app = await CommandFactory.createWithoutRunning(AppModule, ['error', 'fatal']);
+
+    // Now run the command factory.
+    try {
+        await CommandFactory.runApplication(app);
+    }
+    catch (e) {
+        process.exit(1);
+    }
+
+    // Exit explicitly, make sure that any commands you have created and are using Promises, you do not keep them orphan/dangling.
+    process.exit(0);
+}
+
+// https://github.com/typeorm/typeorm/issues/8583
+// const types = require('pg').types;
+// types.setTypeParser(types.builtins.INT8, function(val) {
+//   return parseInt(val)
+// });
+
+bootstrap();

package/src/commands/fixtures/fixtures-setup.command.ts

@@ -0,0 +1,44 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { FixturesService } from 'src/services/fixtures.service';
+
+interface CommandOptions {
+  scenario: string;
+  module: string;
+}
+
+@Command({
+  name: 'fixtures setup',
+  description: 'Handles setup and tear down of fixtures for the SolidX application',
+})
+export class FixturesSetupCommand extends CommandRunner {
+  constructor(
+    private readonly fixturesService: FixturesService,
+  ) {
+    super();
+  }
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+    await this.fixturesService.setupFixtures(options.module, options.scenario);
+  }
+
+  // Accept the task name i.e setup/tear-down for the fixtures command
+  @Option({
+    flags: '-s, --scenario [scenario name]',
+    description: 'Setup scenario name for the fixtures command',
+    required: true,
+  })
+  parseScenario(val: string): string {
+    return val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-m, --module-name [module name]',
+    description: 'Module Name from the ss_model_metadata table',
+    required: true,
+  })
+  parseModule(val: string): string {
+    return val;
+  }
+
+}

package/src/commands/fixtures/fixtures-tear-down.command.ts

@@ -0,0 +1,45 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { SolidIntrospectService } from 'src/services/solid-introspect.service';
+
+interface CommandOptions {
+  scenario: string;
+  module: string;
+}
+
+@Command({
+  name: 'fixtures tear-down',
+  description: 'Handles setup and tear down of fixtures for the SolidX application',
+})
+export class FixturesTearDownCommand extends CommandRunner {
+  constructor(
+    private readonly introspectService: SolidIntrospectService,
+  ) {
+    super();
+  }
+  private readonly logger = new Logger(this.constructor.name);
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+  }
+
+  // Accept the task name i.e setup/tear-down for the fixtures command
+  @Option({
+    flags: '-s, --scenario [scenario name]',
+    description: 'Setup scenario name for the fixtures command',
+    required: true,
+  })
+  parseScenario(val: string): string {
+    return val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-m, --module [module name]',
+    description: 'Module Name from the ss_model_metadata table',
+    required: true,
+  })
+  parseModule(val: string): string {
+    return val;
+  }
+
+}

package/src/commands/helper.ts

@@ -0,0 +1,11 @@
+export class CommandError {
+    error: string;
+    param?: string;
+    constructor(error: string, param: string = null) {
+        this.error = error;
+        this.param = param;
+    }
+    toString() {
+        return `[ error: ${this.error}, param: ${this.param} ]`;
+    }
+}

package/src/commands/info.command.ts

@@ -0,0 +1,98 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ISolidDatabaseModule } from 'src/interfaces';
+import { getDynamicModuleNames } from 'src/helpers/module.helper';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { SettingService } from 'src/services/setting.service';
+
+interface InfoCommandOptions {
+    detailed?: boolean;
+}
+
+@Command({ name: 'info', description: 'Prints information about the consuming project' })
+export class InfoCommand extends CommandRunner {
+    private readonly logger = new Logger(InfoCommand.name);
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry,
+        private readonly settingService: SettingService,
+    ) {
+        super();
+    }
+
+    async run(passedParam: string[], options?: InfoCommandOptions): Promise<void> {
+        const enabledModules = getDynamicModuleNames();
+        const dataSources = this.getDataSources();
+
+        const output: Record<string, any> = {
+            modules: {
+                count: enabledModules.length,
+                names: enabledModules,
+            },
+            dataSources: {
+                count: dataSources.length,
+                items: dataSources,
+            },
+        };
+
+        if (options?.detailed) {
+            output.registry = this.getRegistryDetails();
+        }
+
+        console.log(JSON.stringify(output, null, 2));
+    }
+
+    private getRegistryDetails(): Record<string, unknown> {
+        const info = {
+            settings: this.settingService.getAllSettings(),
+            seeders: this.getWrapperNames(this.solidRegistry.getSeeders()),
+            scheduledJobProviders: this.getWrapperNames(this.solidRegistry.getScheduledJobProviders()),
+            selectionProviders: this.getWrapperNames(this.solidRegistry.getSelectionProviders()),
+            computedFieldProviders: this.getWrapperNames(this.solidRegistry.getComputedFieldProviders()),
+            solidDatabaseModules: this.getWrapperNames(this.solidRegistry.getSolidDatabaseModules()),
+            dashboardVariableSelectionProviders: this.getWrapperNames(this.solidRegistry.getDashboardVariableSelectionProviders()),
+            dashboardQuestionDataProviders: this.getWrapperNames(this.solidRegistry.getDashboardQuestionDataProviders()),
+            mailProviders: this.getWrapperNames(this.solidRegistry.getMailProviders()),
+            whatsappProviders: this.getWrapperNames(this.solidRegistry.getWhatsappProviders()),
+            smsProviders: this.getWrapperNames(this.solidRegistry.getSmsProviders()),
+            securityRuleConfigProviders: this.getWrapperNames(this.solidRegistry.getSecurityRuleConfigProviders()),
+            errorCodeProviders: this.getWrapperNames(this.solidRegistry.getErrorCodeProviders()),
+            controllers: this.solidRegistry.getControllers().map((controller) => controller.name),
+            // modules: this.getWrapperNames(this.solidRegistry.getModules()),
+            // computedFieldMetadata: {
+            //     count: this.solidRegistry.getComputedFieldMetadata().length,
+            // },
+            // defaultLocale: this.solidRegistry.getDefaultLocale()?.locale ?? null,
+        };
+
+        return info;
+    }
+
+    private getWrapperNames(wrappers: Array<{ name?: string; instance?: any }>): string[] {
+        return wrappers
+            .map((wrapper) => wrapper.name || wrapper.instance?.constructor?.name)
+            .filter((name): name is string => !!name);
+    }
+
+    private getDataSources(): Array<{ name: string; type: string | null }> {
+        const fromRegistry = this.solidRegistry
+            .getSolidDatabaseModules()
+            .map((wrapper) => wrapper.instance as ISolidDatabaseModule)
+            .filter((module): module is ISolidDatabaseModule => !!module)
+            .map((module) => ({
+                name: module.name?.(),
+                type: module.type?.() ?? null,
+            }))
+            .filter((item) => !!item.name);
+
+
+        return fromRegistry;
+
+    }
+
+    // Flags
+    @Option({ flags: '-d, --detailed', description: 'Print more details about the consuming project' })
+    parseDetailed(): boolean {
+        return true;
+    }
+}

package/src/commands/ingest.command.ts

@@ -0,0 +1,36 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { IngestMetadataService } from 'src/services/genai/ingest-metadata.service';
+
+interface IngestCommandOptions {
+  module?: string;
+  // seeder?: string;
+}
+
+@Command({ name: 'ingest', description: 'Ingests solid metadata json for all modules deployed in the consuming project' })
+export class IngestCommand extends CommandRunner {
+  private readonly logger = new Logger(IngestCommand.name);
+
+  constructor(
+    private readonly solidRegistry: SolidRegistry,
+    private readonly ingestMetadataService: IngestMetadataService,
+  ) {
+    super();
+  }
+
+  async run(passedParam: string[], options?: IngestCommandOptions): Promise<void> {
+    this.logger.log(`Running the solid ingest for module ${options.module} at ${new Date()}`);
+    await this.ingestMetadataService.ingest();
+  }
+
+  @Option({
+    flags: '-m, --module [module name]',
+    description: 'The seeder to run.',
+    required: false,
+    defaultValue: ''
+  })
+  parseString(val: string): string {
+    return val;
+  }
+}

package/src/commands/mcp.command.ts

@@ -0,0 +1,201 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { Logger } from '@nestjs/common';
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ISolidDatabaseModule } from 'src/interfaces';
+import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+
+interface McpCommandOptions {
+    repoPath?: string;
+    detached?: boolean;
+}
+
+@Command({
+    name: 'mcp',
+    description: 'Manage the SolidX MCP server and Celery worker docker containers (start/stop)',
+})
+export class McpCommand extends CommandRunner {
+    private readonly logger = new Logger(McpCommand.name);
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry
+    ) {
+        super();
+    }
+
+    async run(passedParams: string[], options?: McpCommandOptions): Promise<void> {
+        const mode = (passedParams[0] || 'start').toLowerCase();
+
+        if (mode === 'stop') {
+            await this.stopContainers(options);
+        } else if (mode === 'start') {
+            await this.startContainers(options);
+        } else {
+            this.logger.error(
+                `Unknown mode "${mode}". Supported modes are: start, stop.\n` +
+                'Examples:\n' +
+                '  solid mcp start -p ~/mcp/servers/solidx_mcp_server\n' +
+                '  solid mcp stop  -p ~/mcp/servers/solidx_mcp_server\n'
+            );
+        }
+    }
+
+    // ---------------------------------------------------------------
+    // START
+    // ---------------------------------------------------------------
+    private async startContainers(options?: McpCommandOptions): Promise<void> {
+        // 1. Validate license key
+        const apiKey = process.env.MCP_API_KEY;
+
+        // Form the Database url to be used by the MCP server based on the consuming projects details. 
+        const defaultDatabaseUser = process.env.DEFAULT_DATABASE_USER;
+        const defaultDatabasePwd = process.env.DEFAULT_DATABASE_PASSWORD
+            ? encodeURIComponent(process.env.DEFAULT_DATABASE_PASSWORD)
+            : '';
+        const defaultDatabaseHost = process.env.DEFAULT_DATABASE_HOST === 'localhost' ? 'host.docker.internal' : process.env.DEFAULT_DATABASE_HOST;
+        const defaultDatabaseName = process.env.DEFAULT_DATABASE_NAME;
+        const databaseDialect = process.env.DEFAULT_DATABASE_TYPE?.toLowerCase() === 'mssql' ? 'mssql+pyodbc' : 'postgresql';
+        // const databaseUrl = `${databaseDialect}://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+
+        const defaultDatasource: ISolidDatabaseModule = this.solidRegistry.getDefaultSolidDatabaseModule()
+
+        let databaseUrl: string;
+        if (defaultDatasource.type() === DatasourceType.mssql) {
+            const base = `mssql+pyodbc://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+            const driver = encodeURIComponent('ODBC Driver 18 for SQL Server');
+            databaseUrl = `${base}?driver=${driver}&TrustServerCertificate=yes`;
+        }
+        if (defaultDatasource.type() === DatasourceType.postgres) {
+            databaseUrl = `postgresql://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+        }
+
+        if (!apiKey || apiKey.trim() === '') {
+            this.logger.error(
+                '❌ MCP_API_KEY environment variable is missing.\n' +
+                'Set it before running:\n' +
+                '   export MCP_API_KEY="your_license_key"\n'
+            );
+            return;
+        }
+
+        this.logger.log('✔ MCP_API_KEY found.');
+
+        // 2. Resolve paths
+        const repoPath = options?.repoPath ? this.resolvePath(options.repoPath) : process.cwd();
+        const consumingProjectPath = path.resolve(process.cwd(), '..');
+        const composeFile = path.join(repoPath, 'docker-compose.yml');
+
+        if (!fs.existsSync(composeFile)) {
+            this.logger.error(`docker-compose.yml not found at ${composeFile}`);
+            return;
+        }
+
+        const detached = options?.detached ?? false;
+
+        this.logger.log(`Mode: start`);
+        this.logger.log(`Using repo path: ${repoPath}`);
+        this.logger.log(`Detached mode: ${detached}`);
+        this.logger.log(`Consuming project root: ${consumingProjectPath}`);
+
+        // 3. Build docker compose args
+        const cmd = 'docker';
+        const args = ['compose', '-f', composeFile, 'up'];
+
+        if (detached) {
+            args.push('-d');
+        }
+
+        // Service names as defined in docker-compose.yml
+        args.push('mcp_redis', 'mcp_server', 'mcp_celery_worker');
+
+        const env: NodeJS.ProcessEnv = {
+            ...process.env,
+            MCP_API_KEY: apiKey,
+            HOST_SOLIDX_CONSUMING_PROJECT_ROOT: consumingProjectPath,
+            DATABASE_URL: databaseUrl,
+        };
+
+        this.logger.log(`Running: ${cmd} ${args.join(' ')}`);
+        // const envLog = Object.entries(env)
+        //     .map(([key, value]) => `${key}=${value ?? ''}`)
+        //     .join('\n');
+        // this.logger.log(`Using env overrides:\n${envLog}`);
+
+        await this.runDockerCommand(cmd, args, repoPath, env);
+
+        this.logger.log(
+            detached
+                ? 'MCP containers started in detached mode.'
+                : 'MCP containers started in foreground.'
+        );
+    }
+
+    // ---------------------------------------------------------------
+    // STOP
+    // ---------------------------------------------------------------
+    private async stopContainers(options?: McpCommandOptions): Promise<void> {
+        const repoPath = options?.repoPath ? this.resolvePath(options.repoPath) : process.cwd();
+        const composeFile = path.join(repoPath, 'docker-compose.yml');
+
+        if (!fs.existsSync(composeFile)) {
+            this.logger.error(`docker-compose.yml not found at ${composeFile}`);
+            return;
+        }
+
+        this.logger.log(`Mode: stop`);
+        this.logger.log(`Using repo path: ${repoPath}`);
+
+        const cmd = 'docker';
+        const args = ['compose', '-f', composeFile, 'down'];
+
+        this.logger.log(`Running: ${cmd} ${args.join(' ')}`);
+
+        await this.runDockerCommand(cmd, args, repoPath, process.env);
+
+        this.logger.log('MCP containers stopped (docker compose down).');
+    }
+
+    // ---------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------
+    private resolvePath(inputPath: string): string {
+        if (inputPath.startsWith('~')) {
+            return path.join(process.env.HOME!, inputPath.slice(1));
+        }
+        return path.resolve(inputPath);
+    }
+
+    private runDockerCommand(cmd: string, args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const child = spawn(cmd, args, {
+                cwd,
+                env,
+                stdio: 'inherit',
+            });
+
+            child.on('error', (err) => {
+                this.logger.error(`Docker error: ${err.message}`);
+                reject(err);
+            });
+
+            child.on('close', (code) => {
+                if (code === 0) resolve();
+                else reject(new Error(`Docker exited with code ${code}`));
+            });
+        });
+    }
+
+    // Flags
+    @Option({ flags: '-d, --detached [boolean]', description: 'Run containers in detached mode (only for start, default: false)', required: false, })
+    parseDetached(val: string): boolean {
+        if (val === undefined) return false;
+        return val === 'true' || val === '1';
+    }
+
+    @Option({ flags: '-p, --repo-path [path]', description: 'Path to the SolidX MCP Server repo containing docker-compose.yml', required: false, })
+    parseRepoPath(val: string): string {
+        return val;
+    }
+}

package/src/commands/refresh-model.command.ts

@@ -0,0 +1,107 @@
+import { BadRequestException, forwardRef, Inject, Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { CommandError } from './helper';
+import { In } from 'typeorm';
+
+interface CommandOptions {
+  name?: string;
+  id?: number;
+  fieldIds?: number[];
+  fieldNames?: string[];
+  dryRun?: boolean;
+}
+
+@Command({
+  name: 'refresh-model',
+  description: 'Updates a model and its fields i.e (entity,dto,service,controller files)',
+})
+export class RefreshModelCommand extends CommandRunner {
+  constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
+    private readonly modelMetadataService: ModelMetadataService,
+  ) {
+    super();
+  }
+  private readonly logger = new Logger(RefreshModelCommand.name);
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+    const errors = this.validate(options);
+    if (errors.length) {
+      errors.forEach((error) => this.logger.error(error));
+      return;
+    }
+
+    const codeGenerationOptions = {
+      modelId: options.id,
+      modelUserKey: options.name,
+      dryRun: options.dryRun,
+      fieldIdsForRefresh: options.fieldIds,
+      fieldNamesForRefresh: options.fieldNames,
+    };
+    await this.modelMetadataService.handleGenerateCode(codeGenerationOptions);
+  }
+
+  // Accept the model ID as an argument
+  @Option({
+    flags: '-i, --id [model ID]',
+    description: 'Model ID from the ss_model_metadata table',
+  })
+  parseId(val: string): number {
+    return +val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-n, --name [model name]',
+    description: 'Model Name from the ss_model_metadata table',
+  })
+  parseName(val: string): string {
+    return val;
+  }
+
+  // Accept dry run as an argument
+  @Option({
+    flags: '-d, --dryRun [dry run]',
+    description: 'Dry run the command',
+  })
+  parseDryRun(val: string): boolean {
+    this.logger.debug(`Dry run : ${val}`);
+    return (val === 'false') ? false : true;
+  }
+
+  // Accept field IDs as an argument
+  @Option({
+    flags: '-fids, --fieldIds [Array of field IDs]',
+    description: 'Json array of Field IDs from the ss_field_metadata table',
+  })
+  parseFieldIds(val: string): number[] {
+    //Check if the value is a json array
+    if (!val.startsWith('[') || !val.endsWith(']')) {
+      throw new BadRequestException('Field IDs should be a json array');
+    }
+    return JSON.parse(val).map((id: string) => parseInt(id));
+  }
+
+  // Accept field Names as an argument
+  @Option({
+    flags: '-fnames, --fieldNames [Array of field Names]',
+    description: 'Json array of Field Names from the ss_field_metadata table',
+  })
+  parseFieldNames(val: string): string[] {
+    //Check if the value is a json array
+    if (!val.startsWith('[') || !val.endsWith(']')) {
+      throw new BadRequestException('Field Names should be a json array');
+    }
+    return JSON.parse(val).map((name: string) => name.toString());
+  }
+
+  // Validate the options passed
+  private validate(options: CommandOptions): CommandError[] {
+    if (!options.id && !options.name) {
+      return [new CommandError('Model ID or Model Name is required')];
+    }
+    return [];
+  }
+
+}

package/src/commands/refresh-module.command.ts

@@ -0,0 +1,73 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ModuleMetadataService } from '../services/module-metadata.service';
+import { CommandError } from './helper';
+
+interface CommandOptions {
+  id: number;
+  name: string;
+  dryRun: boolean;
+}
+
+@Command({
+  name: 'refresh-module',
+  description: 'Refreshes a module and its model and fields i.e (entity,dto,service,controller files)',
+})
+export class RefreshModuleCommand extends CommandRunner {
+  constructor(
+    private readonly moduleMetadataService: ModuleMetadataService,
+  ) {
+    super();
+  }
+  private readonly logger = new Logger(RefreshModuleCommand.name);
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+    const errors = this.validate(options);
+    if (errors.length) {
+      errors.forEach((error) => this.logger.error(error));
+      return;
+    }
+    const codeGenerationOptions = {
+      moduleId: options.id,
+      moduleUserKey: options.name,
+      dryRun: options.dryRun,
+    };
+    await this.moduleMetadataService.generateCode(codeGenerationOptions);
+  }
+
+  @Option({
+    flags: '-i, --id [module ID]',
+    description: 'Module ID from the ss_module_metadata table',
+  })
+  parseId(val: string): number {
+    return +val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-n, --name [module name]',
+    description: 'Module Name from the ss_module_metadata table',
+  })
+  parseName(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '-d, --dryRun [dry run]',
+    description: 'Dry run the command',
+  })
+  parseDryRun(val: string): boolean {
+    this.logger.debug(`Dry run : ${val}`);
+    return (val === 'false') ? false : true;
+  }
+
+
+  // Validate the options passed
+  validate(options: CommandOptions): CommandError[] {
+    if (!options.id && !options.name) {
+      return [new CommandError('Module ID or Module Name is required')];
+    }
+    return [];
+  }
+
+}