@solidxai/core 0.1.10-beta.2 → 0.1.10-beta.21

package/src/subscribers/security-rule.subscriber.ts

@@ -27,19 +27,19 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
     async afterInsert(event: InsertEvent<SecurityRule>) {
         await this.saveSecurityRules(event);
     }
-    
+
     async afterUpdate(event: UpdateEvent<SecurityRule>) {
         await this.saveSecurityRules(event);
     }
 
-    async saveSecurityRules(event: UpdateEvent<SecurityRule>| InsertEvent<SecurityRule>) {
+    async saveSecurityRules(event: UpdateEvent<SecurityRule> | InsertEvent<SecurityRule>) {
         const securityRule = event.entity as SecurityRule;
         const modelMetadata = event.entity.modelMetadata;
         if (!modelMetadata) {
             this.logger.error(`Model metadata not found for security rule with id ${event.entity.id}`);
             return;
         }
-        
+
         const modelMetadataRepo = this.dataSource.getRepository(ModelMetadata);
         const populatedModelMetadata = await modelMetadataRepo.findOne({
             where: {
@@ -58,7 +58,7 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
         const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(populatedModelMetadata.module.name);
         try {
             await fs.access(filePath);
-        } catch (error) {
+        } catch (error: any) {
             // FIXME - Should we actually delete the security rule here, if the file is not found?
             this.logger.error(`File not found at path: ${filePath}`);
             return;
@@ -67,13 +67,13 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
 
         if (metaData.securityRules) {
             const securityRuleIndex = metaData.securityRules?.findIndex((ruleFromFile: { name: string }) => ruleFromFile.name === securityRule.name);
-            const {id, roleId, modelMetadataId, ...requiredDto} = await this.securityRuleRepo.toDto(securityRule)
-            metaData.securityRules[securityRuleIndex] = {...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig)}
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
+            metaData.securityRules[securityRuleIndex] = { ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) }
         }
         else {
             const securityRules = []
-            const {id, roleId, modelMetadataId, ...requiredDto} = await this.securityRuleRepo.toDto(securityRule)
-            securityRules.push({...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig)})
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
+            securityRules.push({ ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) })
             metaData.securityRules = securityRules
         }
         // Write the updated object back to the file

package/src/subscribers/view-metadata.subscriber.ts

@@ -43,7 +43,7 @@ export class ViewMetadataSubsciber implements EntitySubscriberInterface<ViewMeta
             const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(viewMetadata.model.module.name);
             try {
                 await fs.access(filePath);
-            } catch (error) {
+            } catch (error: any) {
                 this.logger.error(`File not found at path: ${filePath}`);
                 return;
             }

package/src/testing/README.md

@@ -356,6 +356,21 @@ await runFromMetadata({
 });
 ```
 
+## CLI Workflows
+Full isolated-database workflow:
+1. `npx @solidxai/solidctl@latest test data --setup`
+2. `npx @solidxai/solidctl@latest seed`
+3. `npx @solidxai/solidctl@latest test data --load`
+4. `npx @solidxai/solidctl@latest test run --module <module-name>`
+5. `npx @solidxai/solidctl@latest test data --teardown`
+
+Lightweight existing-database workflow:
+1. `npx @solidxai/solidctl@latest test data --load`
+2. `npx @solidxai/solidctl@latest test run --module <module-name>`
+3. `npx @solidxai/solidctl@latest test data --unlink`
+
+`test data --unlink` deletes records declared in `testing.data` in reverse order using each model's `userKeyFieldUserKey` and the entry's `recUserKeyValue`. This assumes `testing.data` is authored in dependency order, with parent records appearing before dependent records.
+
 ## Add A New Step (SOP)
 1. Create a new `*.step.ts` in the right domain folder.
 2. Implement a `registerXSteps(registry)` function and `registry.register("op.name", handler)`.

package/src/testing/core/testing-engine.ts

@@ -57,7 +57,7 @@ export class TestingEngine {
         } else {
           await execute();
         }
-      } catch (err) {
+      } catch (err: any) {
         scenarioError = err;
       } finally {
         const durationMs = Date.now() - scenarioStart;
@@ -108,7 +108,7 @@ export class TestingEngine {
           // console.log(`Step ${resolvedStep.name} attempting to saveAs ${resolvedStep.saveAs}`, JSON.stringify(result));
           ctx.resources.set(resolvedStep.saveAs, result);
         }
-      } catch (err) {
+      } catch (err: any) {
         stepError = err;
         throw err;
       } finally {

package/src/testing/reporter/console-reporter.ts

@@ -146,6 +146,10 @@ function formatStepLabel(step: OpStep): string {
 }
 
 export class ConsoleReporter implements Reporter {
+  private totalScenarios = 0;
+  private passedScenarios = 0;
+  private failedScenarios = 0;
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);
@@ -157,6 +161,12 @@ export class ConsoleReporter implements Reporter {
   ): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     const status = result.ok ? "✔" : "✖";
+    this.totalScenarios += 1;
+    if (result.ok) {
+      this.passedScenarios += 1;
+    } else {
+      this.failedScenarios += 1;
+    }
     console.log(`${status} Scenario: ${label} (${result.durationMs}ms)`);
   }
 
@@ -226,4 +236,21 @@ export class ConsoleReporter implements Reporter {
     if (!dataText.length) return;
     console.log(indentLines(dataText, `${STEP_INDENT}${INDENT}${INDENT}`));
   }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    const durationSeconds = (args.durationMs / 1000).toFixed(2);
+    const finalStatus = args.ok ? "PASSED" : "FAILED";
+
+    console.log("\n════════ Test Run Summary ════════");
+    console.log(`Result: Test run ${finalStatus}`);
+    console.log(`Cases: total=${args.total}, passed=${args.passed}, failed=${args.failed}`);
+    console.log(`Duration: ${durationSeconds}s`);
+    console.log("══════════════════════════════════");
+  }
 }

package/src/testing/reporter/reporter.types.ts

@@ -33,4 +33,11 @@ export interface Reporter {
     contentType: string;
     data: Buffer | string;
   }): void;
+  onRunEnd?(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void;
 }

package/src/testing/reporter/webhook-reporter.ts

@@ -109,7 +109,7 @@ export class WebhookReporter extends ConsoleReporter {
       if (!response.ok) {
         console.warn(`[WebhookReporter] Webhook returned ${response.status}`);
       }
-    } catch (err) {
+    } catch (err: any) {
       console.warn(`[WebhookReporter] Failed to deliver test results: ${err}`);
     }
   }

package/src/testing/runner/run-from-metadata.ts

@@ -44,6 +44,7 @@ export type RunnerOptions = {
 };
 
 export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
+  const startedAt = Date.now();
   const registry = new StepRegistry();
   registerApiSteps(registry);
   registerUiSteps(registry);
@@ -71,15 +72,32 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
   const ui = new PlaywrightAdapter(opts.ui);
   const ctxBase = { resources, reporter, api, ui, specRegistry, testData, options: opts.options };
   const uiStarted = { value: false };
+  let passed = 0;
+  let failed = 0;
+  let runError: unknown;
 
   try {
     for (const scenario of scenarios) {
       if (scenarioNeedsUi(scenario)) {
         await ensureUiStarted(ctxBase, uiStarted);
       }
-      await engine.runScenario(scenario, ctxBase);
+      try {
+        await engine.runScenario(scenario, ctxBase);
+        passed += 1;
+      } catch (error) {
+        failed += 1;
+        runError = error;
+        throw error;
+      }
     }
   } finally {
+    reporter.onRunEnd?.({
+      ok: !runError,
+      total: scenarios.length,
+      passed,
+      failed,
+      durationMs: Date.now() - startedAt,
+    });
     if (uiStarted.value) {
       await ui.stop();
     }

package/src/winston.logger.ts

@@ -6,8 +6,8 @@ import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import * as winston from 'winston';
 import { Environment } from './decorators/disallow-in-production.decorator';
 
-export const WinstonLoggerConfig = {
-    level: process.env.LOG_LEVEL || (process.env.ENV === Environment.Production ? 'info' : 'debug'),
+export const createWinstonLoggerConfig = () => ({
+    level: process.env.LOG_LEVEL || (process.env.ENV === Environment.Production ? 'warn' : 'info'),
     format: winston.format.combine(
         winston.format.timestamp(),
         winston.format.errors({ stack: true }),
@@ -21,8 +21,6 @@ export const WinstonLoggerConfig = {
     transports: [
         new winston.transports.Console({
             format: winston.format.combine(
-                // winston.format.colorize(),
-                // winston.format.timestamp(),
                 winston.format.printf(({ level, message, timestamp }) => {
                     return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
                 }),
@@ -30,15 +28,15 @@ export const WinstonLoggerConfig = {
         }),
         new winston.transports.File({
             filename: 'logs/application.log',
-            // format: winston.format.json(),
         }),
         new winston.transports.File({
             filename: 'logs/error.log',
             level: 'error',
-            // format: winston.format.json(),
         }),
     ],
-};
+});
+
+export const WinstonLoggerConfig = createWinstonLoggerConfig();
 
 export class WinstonTypeORMLogger implements TypeORMLogger {
     constructor(@Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger) { }

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node -e:*)",
-      "WebFetch(domain:docs.solidxai.com)",
-      "WebFetch(domain:github.com)",
-      "Read(//Users/oswald/projects/Solid_Starters/solidctl/**)",
-      "Read(//Users/oswald/projects/Solid_Starters/**)",
-      "Bash(find /Users/oswald/projects/Solid_Starters/solid-core-module -type d -name migration* -o -name *database*)"
-    ],
-    "additionalDirectories": [
-      "/Users/oswald/projects/Solid_Starters/solidctl"
-    ]
-  }
-}

package/src/services/1.js

@@ -1,6 +0,0 @@
-1. Do i need to create a storeStreams method for aws service too?
-    - Handle later
-2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
-    - startExport should either return the data or return the transaction id
-3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
-    - show the userKey