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

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

@@ -15,6 +15,12 @@
 {
   "testing": {
     "specs": ["path/to/register-test-specs.js"],
+    "roles": [
+      { "name": "Editor", "permissions": ["BookController.*"] }
+    ],
+    "users": [
+      { "username": "testEditor", "email": "testEditor@test.local", "password": "Test@1234", "roles": ["Editor"] }
+    ],
     "data": [
       {
         "modelUserKey": "stateMaster",
@@ -227,6 +233,37 @@ Options in `with`:
 - `selector` (required)
 - `key` (required)
 
+### **Op: `ui.waitForManual`**
+Description: Pauses a headed Playwright run so a human can interact with the live browser, then resumes when Enter is pressed in the terminal.
+
+Options in `with`:
+- `message` (optional, defaults to a generic instruction)
+- `prompt` (optional, defaults to `Press Enter to continue...`)
+- `waitForSelector` (optional, waits for a visible selector after resume)
+- `waitForUrlEquals` (optional, waits until the current URL exactly matches)
+- `waitForUrlContains` (optional, waits until the current URL contains a substring)
+- `timeoutMs` (optional, timeout for post-resume waits)
+- `bringToFront` (optional, defaults to `true`)
+
+Notes:
+- Requires `--headless false`.
+- Requires an interactive terminal (TTY).
+- Useful for OTP screens or third-party verification challenges that must be completed by a human.
+
+Example:
+```json
+{
+  "then": {
+    "op": "ui.waitForManual",
+    "with": {
+      "message": "Enter the OTP in the browser, then return here to continue.",
+      "waitForSelector": "text=Dashboard",
+      "timeoutMs": 30000
+    }
+  }
+}
+```
+
 ### **Op: `ui.expectVisible`**
 Description: Waits for an element to be visible.
 
@@ -340,7 +377,6 @@ await runFromMetadata({
 When using `solidctl test run`, specs are loaded from `testing.specs` in module metadata.
 Use `--skip-scenario-ids` to exclude scenarios by id (comma-separated).
 Use `--print-api-logs` to print full API request/response details for `api.request` steps.
-Use `--print-api-logs` to print full API request/response details for `api.request` steps.
 
 ## Run From Metadata
 ```ts
@@ -356,9 +392,26 @@ 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> --headless false`
+3. `npx @solidxai/solidctl@latest test data --unlink`
+
+`test data --unlink` deletes records declared in `testing.data` in reverse order using each model's actual `userKeyFieldUserKey` value from `testing.data[*].data`. This assumes `testing.data` is authored in dependency order, with parent records appearing before dependent records.
+
+For human-assisted OTP or third-party verification flows, use `ui.waitForManual` in a headed run so the browser remains interactive while the scenario is paused.
+
 ## 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)`.
 3. Validate required `step.with` fields and throw clear errors.
 4. Use adapters via `ctx.api` / `ctx.ui` and update `ctx.last` when helpful.
-5. Export and register it from the domain `index.ts`.
+5. Export and register it from the domain `index.ts`.

package/src/testing/adapters/ui/playwright-adapter.ts

@@ -18,6 +18,10 @@ export class PlaywrightAdapter {
     this.headless = opts?.headless ?? true;
   }
 
+  isHeadless(): boolean {
+    return this.headless;
+  }
+
   async start(): Promise<void> {
     const { chromium } = await import('playwright');
     this.browser = await chromium.launch({ headless: this.headless });

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/testing/steps/ui/index.ts

@@ -3,10 +3,12 @@ import { registerNavigationSteps } from "./navigation.step";
 import { registerFormSteps } from "./form.step";
 import { registerActionSteps } from "./actions.step";
 import { registerAssertionSteps } from "./assertions.step";
+import { registerManualSteps } from "./manual.step";
 
 export function registerUiSteps(registry: StepRegistry): void {
   registerNavigationSteps(registry);
   registerFormSteps(registry);
   registerActionSteps(registry);
   registerAssertionSteps(registry);
+  registerManualSteps(registry);
 }

package/src/testing/steps/ui/manual.step.ts

@@ -0,0 +1,80 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import type { TestContext } from "../../contracts/runtime-context.types";
+import type { OpStep } from "../../contracts/testing-metadata.types";
+import { StepRegistry } from "../../core/step-registry";
+
+type WaitForManualInput = {
+  message?: string;
+  prompt?: string;
+  waitForSelector?: string;
+  waitForUrlContains?: string;
+  waitForUrlEquals?: string;
+  timeoutMs?: number;
+  bringToFront?: boolean;
+};
+
+function requirePage(ctx: TestContext, op: string) {
+  if (!ctx.ui || !ctx.ui.page) {
+    throw new Error(`Missing UI page on context for op "${op}"`);
+  }
+  return ctx.ui.page;
+}
+
+export function registerManualSteps(registry: StepRegistry): void {
+  registry.register("ui.waitForManual", async (ctx: TestContext, step: OpStep) => {
+    const page = requirePage(ctx, "ui.waitForManual");
+    const inputConfig = (step.with ?? {}) as WaitForManualInput;
+    const message = inputConfig.message?.trim() || "Manual interaction required.";
+    const prompt = inputConfig.prompt?.trim() || "Press Enter to continue...";
+    const timeoutMs = inputConfig.timeoutMs;
+    const bringToFront = inputConfig.bringToFront ?? true;
+
+    if (ctx.ui?.isHeadless()) {
+      throw new Error('Op "ui.waitForManual" requires headed mode. Re-run with --headless false.');
+    }
+    if (!input.isTTY || !output.isTTY) {
+      throw new Error('Op "ui.waitForManual" requires an interactive terminal (TTY).');
+    }
+
+    if (bringToFront) {
+      await page.bringToFront();
+    }
+
+    console.log("");
+    console.log("════════ Manual Interaction Required ════════");
+    console.log(message);
+    console.log(`Scenario: ${ctx.scenarioId}`);
+    console.log(`Current URL: ${page.url()}`);
+    console.log(prompt);
+
+    const rl = createInterface({ input, output });
+    try {
+      await rl.question("");
+    } finally {
+      rl.close();
+    }
+
+    if (inputConfig.waitForSelector) {
+      await page.waitForSelector(inputConfig.waitForSelector, {
+        state: "visible",
+        timeout: timeoutMs,
+      });
+    }
+
+    if (inputConfig.waitForUrlEquals) {
+      await page.waitForURL(
+        (url) => url.toString() === inputConfig.waitForUrlEquals,
+        { timeout: timeoutMs },
+      );
+    }
+
+    if (inputConfig.waitForUrlContains) {
+      await page.waitForURL(
+        (url) => url.toString().includes(String(inputConfig.waitForUrlContains)),
+        { timeout: timeoutMs },
+      );
+    }
+  });
+}

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) { }