@thinkwise/testwise 0.1.97 → 0.2.0-beta.22

package/Testwise.ts

@@ -1,6 +1,8 @@
 import { test as base } from '@playwright/test';
 import { test as bddBase } from 'playwright-bdd';
 import { Components, GoToDeepLink, LoginFeatures, UserSimulation } from './page-extensions/index.js';
+import { SubjectProvider } from './page-extensions/SubjectProvider.js';
+import { SubjectRegistry } from './page-extensions/SubjectRegistry.js';
 import { WaitEventHandler } from './page-extensions/WaitEventHandler.js';
 import { ClickOverride } from './page-overrides/ClickOverride.js';
 import { FillOverride } from './page-overrides/FillOverride.js';
@@ -20,15 +22,11 @@ const extensions = [
   GoToDeepLink,
   LoginFeatures,
   UserSimulation,
-  WaitEventHandler
+  WaitEventHandler,
+  SubjectRegistry,
+  SubjectProvider
 ];
 
-export const test: Test = combineExtensions(
-  base,
-  ...extensions
-);
+export const test: Test = combineExtensions(base, ...extensions);
 
-export const bddTest: Test = combineExtensions(
-  bddBase,
-  ...extensions
-);
+export const bddTest: Test = combineExtensions(bddBase, ...extensions);

package/artifact-builder/ArtifactManager.ts

@@ -0,0 +1,33 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export class ArtifactManager {
+  private _backupPath: string;
+  private _artifactPath: string;
+
+  constructor() {
+    const _filename = fileURLToPath(import.meta.url);
+    const _dirname = path.dirname(_filename);
+    this._backupPath = path.resolve(_dirname, '..', '..', '..', 'backups', 'test-artifacts');
+    this._artifactPath = path.resolve(_dirname, '..', '..', 'test-artifacts');
+  }
+
+  performBackup() {
+    if (fs.existsSync(this._artifactPath)) {
+      fs.rmSync(this._backupPath, { recursive: true, force: true });
+      fs.cpSync(this._artifactPath, this._backupPath, { recursive: true });
+    }
+  }
+
+  backupExists(): boolean {
+    return fs.existsSync(this._backupPath);
+  }
+
+  restoreBackup(): void {
+    if (fs.existsSync(this._backupPath)) {
+      fs.rmSync(this._artifactPath, { recursive: true, force: true });
+      fs.cpSync(this._backupPath, this._artifactPath, { recursive: true });
+    }
+  }
+}

package/artifact-builder/InterfaceGenerator.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as prettier from 'prettier';
+import { FetchingJSONSchemaStore, InputData, JSONSchemaInput, quicktype } from 'quicktype-core';
+import { PathResolver } from '../helpers/PathResolver.js';
+import { NamingHandler } from '../index.js';
+
+export class InterfaceGenerator {
+  private readonly _namingHandler: NamingHandler;
+  private _filename: string;
+  private _dirname: string;
+
+  constructor() {
+    this._namingHandler = new NamingHandler();
+    this._filename = fileURLToPath(import.meta.url);
+    this._dirname = path.dirname(this._filename);
+  }
+
+  public async generateScreenInterfacesFromSchemas() {
+    const screenOutputDirectory = path.resolve(this._dirname, '..', '..', 'test-artifacts/screens/');
+    this.verifyOutputDirectory(screenOutputDirectory);
+
+    const schemasDirectory = this.getScreenSchemaFilesPath();
+
+    await this.generateInterfacesFromSchemaFiles(schemasDirectory, SchemaType.Screen, screenOutputDirectory);
+
+    console.info('All screen schemas processed.');
+  }
+
+  public async generateSubjectInterfacesFromSchemas() {
+    const schemasDirectory = path.resolve(this._dirname, '../test-artifacts/schemas');
+    const subjectOutputDirectory = path.resolve(this._dirname, '..', '..', 'test-artifacts/subjects');
+
+    this.verifyGeneratedSubjectSchemasDirectory(schemasDirectory);
+    this.verifyOutputDirectory(subjectOutputDirectory);
+
+    await this.generateInterfacesFromSchemaFiles(schemasDirectory, SchemaType.Subject, subjectOutputDirectory);
+
+    console.info('All subject schemas processed.');
+  }
+
+  private verifyGeneratedSubjectSchemasDirectory(directory: string) {
+    if (!fs.existsSync(directory)) {
+      return;
+    }
+  }
+
+  private verifyOutputDirectory(directory: string) {
+    if (!fs.existsSync(directory)) {
+      fs.mkdirSync(directory, { recursive: true });
+    }
+  }
+
+  private getGeneratedSubjectSchemas(schemasDirectory: string): string[] {
+    return fs.readdirSync(schemasDirectory).filter((f) => f.endsWith('.json'));
+  }
+
+  private verifySubjectComponentsDirectory(directory: string, subject: string) {
+    const componentsDirectory = path.join(directory, `${subject}/Components`);
+    if (!fs.existsSync(componentsDirectory)) {
+      fs.mkdirSync(componentsDirectory, { recursive: true });
+    }
+
+    return componentsDirectory;
+  }
+
+  private async createInterfaceFromSchema(
+    schemasDirectory: string,
+    outputPath: string,
+    file: string,
+    isInterface: boolean = false
+  ): Promise<boolean> {
+    try {
+      const baseFileName = file.slice(0, file.lastIndexOf('.'));
+      const correctInterfaceName = isInterface
+        ? this._namingHandler.generateScreenInterfaceName(baseFileName)
+        : this._namingHandler.snakeToPascalCase(baseFileName);
+
+      const schemaPath = path.join(schemasDirectory, file);
+      const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+
+      const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+      await schemaInput.addSource({
+        name: correctInterfaceName,
+        schema: schemaContent
+      });
+
+      const inputData = new InputData();
+      inputData.addInput(schemaInput);
+
+      const result = await quicktype({
+        inputData,
+        lang: 'typescript',
+        rendererOptions: { 'just-types': 'true', 'nice-property-names': 'true' }
+      });
+
+      let updatedContent = result.lines.join('\n');
+
+      updatedContent = updatedContent.replace(/interface\s+\w+/, `interface ${correctInterfaceName}`);
+
+      const formattedContent = await prettier.format(updatedContent, {
+        parser: 'typescript',
+        singleQuote: true,
+        semi: true,
+        trailingComma: 'all'
+      });
+
+      fs.writeFileSync(outputPath, formattedContent, 'utf-8');
+
+      return true;
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error processing ${file}:`, error.message);
+      } else {
+        console.error(`Error processing ${file}:`, error);
+      }
+      throw error;
+    }
+  }
+
+  private async generateInterfacesFromSchemaFiles(
+    schemasDirectory: string,
+    schemaType: SchemaType,
+    outputPath: string
+  ): Promise<void> {
+    const schemaFiles: string[] = this.getGeneratedSubjectSchemas(schemasDirectory);
+
+    const tasks = schemaFiles.map(async (file) => {
+      const fileName = this._namingHandler.getPascalSubjectComponentName(file);
+
+      if (schemaType === SchemaType.Subject) {
+        const subject = this._namingHandler.getSubjectFromFileName(fileName);
+        const componentsDirectory = this.verifySubjectComponentsDirectory(outputPath, subject);
+        const perFileOutputPath = path.join(componentsDirectory, `${fileName}.ts`);
+        return this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file);
+      }
+
+      if (schemaType === SchemaType.Screen) {
+        const perFileOutputPath = path.join(outputPath, `I${fileName}.ts`);
+        return this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file, true);
+      }
+
+      throw new Error(`Unsupported schema type: ${schemaType}`);
+    });
+
+    await Promise.all(tasks);
+  }
+
+  public getScreenSchemaFilesPath(): string {
+    const directory = new PathResolver().getConsumerRootDirectory();
+
+    const screenSchemasPath = path.join(directory, 'seed-data/screen-schemas/');
+    if (!fs.existsSync(screenSchemasPath)) {
+      throw new Error(`Screen schemas directory not found at: ${screenSchemasPath}`);
+    }
+
+    return screenSchemasPath;
+  }
+}
+
+enum SchemaType {
+  Subject = 'Subject',
+  Screen = 'Screen'
+}

package/artifact-builder/ModelDataBuilder.ts

@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** biome-ignore-all lint/style/noNonNullAssertion: Because I can */
+/** biome-ignore-all lint/suspicious/noExplicitAny: Because I can */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import axios from 'axios';
+import type { IProperty } from '../interfaces/IProperty.js';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+import { DataRetriever } from './helpers/DataRetriever.js';
+
+type Subjects = {
+  subject: string;
+  variant: string;
+  screentype_context: string;
+  screentype_id: 'main' | 'detail' | 'zoom' | 'popup';
+  properties?: IProperty[];
+};
+
+const serviceUrl: string = testwiseConfig().get<string>('environmentSettings.serviceUrl')!.replace(/\/$/, '');
+const metaEndpoint: string = testwiseConfig()
+  .get<string>('environmentSettings.metaEndpoint')!
+  .replace(/^\//, '')
+  .replace(/\/$/, '');
+const authUser: string = testwiseConfig().get<string>('environmentSettings.authUser')!;
+const authUserPassword: string = testwiseConfig().get<string>('environmentSettings.authUserPassword')!;
+
+const axiosInstance = axios.create({
+  baseURL: serviceUrl,
+  headers: {
+    Authorization: `Basic ${Buffer.from(`${authUser}:${authUserPassword}`).toString('base64')}`,
+    accept: '*/*'
+  }
+});
+
+const guiApplId: number = await getGuiApplId();
+
+export async function buildSubjects() {
+  const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_tab?$filter=gui_appl_id%20eq%20${guiApplId}`);
+
+  const rawTabs: any[] = response.data?.value || [];
+
+  const subjects: Subjects[] = rawTabs
+    .flatMap((tab: any) => {
+      const base = {
+        subject: tab.tab_id,
+        variant: tab.tab_variant_id
+      };
+
+      return [
+        { ...base, screentype_id: tab.main_screen_type_id, screentype_context: 'main' },
+        { ...base, screentype_id: tab.detail_screen_type_id, screentype_context: 'detail' },
+        { ...base, screentype_id: tab.zoom_screen_type_id, screentype_context: 'zoom' },
+        { ...base, screentype_id: tab.popup_screen_type_id, screentype_context: 'popup' }
+      ];
+    })
+    .filter((item) => item.screentype_id !== 'not_visible_in_gui');
+
+  const colResponse = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_col?$filter=gui_appl_id%20eq%20${guiApplId}`);
+
+  const allProperties: IPropertyWithSubjectIdentifiers[] = colResponse.data?.value.map((col: any) => ({
+    subject: col.tab_id,
+    variant: col.tab_variant_id,
+    col: col.col_id,
+    control_type: col.control_id || ''
+  }));
+
+  for (const subject of subjects) {
+    const matchingProperties = allProperties.filter(
+      (prop) => prop.subject === subject.subject && prop.variant === subject.variant
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    subject.properties = matchingProperties.map(({ subject, variant, ...rest }) => rest);
+  }
+
+  const subjectsWithLookupsSet = await setLookupDropdowns(subjects);
+
+  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
+
+  const seedDataPath = path.join(seedDataDirectory, 'subjects.json');
+  await fs.writeFile(seedDataPath, JSON.stringify(subjectsWithLookupsSet, null, 2), 'utf-8');
+  console.log(`Seed data written to ${seedDataPath}`);
+}
+
+async function setLookupDropdowns(subjects: Subjects[]): Promise<Subjects[]> {
+  const response = await axiosInstance.get(
+    `/iam/${metaEndpoint}/i_ui_tab_look_up?$filter=gui_appl_id%20eq%20${guiApplId}`
+  );
+
+  const lookupMappings: any[] = response.data?.value || [];
+
+  for (const mapping of lookupMappings) {
+    const targetSubject = subjects.find(
+      (subj) => subj.subject === mapping.tab_id && subj.variant === mapping.tab_variant_id
+    );
+
+    const targetProperty = targetSubject?.properties?.find((prop) => prop.col === mapping.col_id);
+
+    if (targetProperty) {
+      targetProperty.control_type = 'LOOKUP_DROPDOWN';
+    }
+  }
+
+  return subjects;
+}
+
+export async function buildScreens() {
+  const response = await axiosInstance.get(
+    `/iam/${metaEndpoint}/i_ui_screen_component?$filter=gui_appl_id eq ${guiApplId}`
+  );
+
+  const rawComponents = response.data?.value || [];
+  const screenMap = new Map<string, any>();
+
+  for (const item of rawComponents) {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { screen_type_id, screen_component_id, screen_component_type_id } = item;
+
+    if (screen_component_id.includes(':')) continue;
+
+    if (!screenMap.has(screen_type_id)) {
+      screenMap.set(screen_type_id, { ScreenTypeId: screen_type_id, Components: [] });
+    }
+
+    screenMap.get(screen_type_id).Components.push({
+      ScreenComponentId: screen_component_id,
+      ScreenComponentType: screen_component_type_id
+    });
+  }
+
+  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
+  const outputDir = path.join(seedDataDirectory, 'screen-schemas');
+  await fs.mkdir(outputDir, { recursive: true });
+
+  for (const [screenTypeId, screenData] of screenMap.entries()) {
+    const usedTypes = new Set<string>();
+    const properties: Record<string, any> = {};
+    const required: string[] = [];
+
+    for (const comp of screenData.Components) {
+      const type = comp.ScreenComponentType;
+      properties[comp.ScreenComponentId] = { $ref: `#/definitions/${type}` };
+      required.push(comp.ScreenComponentId);
+      usedTypes.add(type);
+    }
+
+    const schema = {
+      title: `I_${screenTypeId}`,
+      type: 'object',
+      properties,
+      required,
+      additionalProperties: false,
+      definitions: Array.from(usedTypes).reduce((acc, type) => {
+        acc[type] = {
+          type: 'object',
+          properties: { temp: { type: 'string' } },
+          required: ['temp'],
+          additionalProperties: false
+        };
+        return acc;
+      }, {} as any)
+    };
+
+    await fs.writeFile(path.join(outputDir, `${screenTypeId}.json`), JSON.stringify(schema, null, 2));
+  }
+  console.log('Screen schemas generated successfully.');
+}
+
+async function getGuiApplId(): Promise<number> {
+  const guiApplAlias = testwiseConfig().get<string>('environmentSettings.guiApplAlias');
+
+  if (guiApplAlias) {
+    const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_gui_appl`);
+    const guiAppl = response.data?.value.find((appl: any) => {
+      const currentAlias = appl?.gui_appl_alias?.toString();
+      const targetAlias = guiApplAlias?.toString();
+
+      return currentAlias === targetAlias;
+    });
+
+    if (guiAppl) {
+      return guiAppl.gui_appl_id;
+    } else {
+      throw new Error(`No GUI Application found for GUI Application Alias: ${guiApplAlias}`);
+    }
+  } else {
+    throw new Error('GUI Application Alias is not defined in the configuration.');
+  }
+}
+
+interface IPropertyWithSubjectIdentifiers extends IProperty {
+  subject: string;
+  variant: string;
+}

package/artifact-builder/ModelDataRefiner.ts

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DataRetriever } from '../index.js';
+import type { IRegisteredSubjects } from '../interfaces/IRegisteredSubjects.js';
+
+export class ModelDataRefiner {
+  private _dataRetriever = new DataRetriever();
+
+  public run() {
+    const seedDataDir = this._dataRetriever.getSeedDataDirectory();
+    const registeredSubjects: IRegisteredSubjects[] | null = this._dataRetriever.getRegisteredSubjects();
+
+    if (!registeredSubjects || registeredSubjects.length === 0) {
+      console.info('No registered subjects found.');
+      return;
+    }
+
+    const subjects = this._dataRetriever.getSubjectsSeedData();
+
+    const subjectsToBuild = subjects.filter((subject) =>
+      registeredSubjects.some(
+        (registered) =>
+          registered.subject === subject.subject &&
+          (registered.variant != null ? registered.variant === subject.variant : subject.variant === '') &&
+          registered.screen_type === subject.screentype_context
+      )
+    );
+
+    const subjectsToBuildPath = path.resolve(seedDataDir, 'subjectsToBuild.json');
+    fs.writeFileSync(subjectsToBuildPath, JSON.stringify(subjectsToBuild, null, 2));
+    console.log(`Created subjectsToBuild.json with ${subjectsToBuild.length} subjects.`);
+
+    const screensToBuild = Array.from(new Set(subjectsToBuild.map((subject) => subject.screentype_id)));
+
+    const screensToBuildPath = path.resolve(seedDataDir, 'screensToBuild.json');
+    fs.writeFileSync(screensToBuildPath, JSON.stringify(screensToBuild, null, 2));
+    console.log(`Created screensToBuild.json with ${screensToBuild.length} screens.`);
+  }
+}

package/artifact-builder/SchemaGenerator.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DataRetriever } from '../index.js';
+import type { ISubject } from '../interfaces/ISubject.js';
+import type { SubjectComponents } from '../types/Components.js';
+import { NamingHandler } from './helpers/NamingHandler.js';
+
+const currentFilename = fileURLToPath(import.meta.url);
+const currentDirname = dirname(currentFilename);
+
+export class SchemaGenerator {
+  private _namingHandler: NamingHandler;
+  private _dataRetriever: DataRetriever;
+
+  constructor() {
+    this._namingHandler = new NamingHandler();
+    this._dataRetriever = new DataRetriever();
+  }
+
+  public generateSchema() {
+    const schemasDir = path.resolve(currentDirname, '../dist/test-artifacts/schemas');
+
+    if (!fs.existsSync(schemasDir)) {
+      fs.mkdirSync(schemasDir, { recursive: true });
+    }
+
+    const subjects = this._dataRetriever.getSubjectsToBuild();
+
+    for (const subject of subjects) {
+      this.createSubjectSchema(subject);
+    }
+  }
+
+  public iSubjectToJson(value: ISubject): string {
+    return JSON.stringify(value);
+  }
+
+  // Changes start here
+  private createSubjectSchema(subject: ISubject): void {
+    const screen = { content: this.getScreenContent(subject.screentype_id) };
+    const componentsToProcess = this.getComponentsToProcess(screen);
+
+    for (const component of componentsToProcess) {
+      switch (component) {
+        case 'Form':
+          this.createComponentSchema(subject, 'Form');
+          break;
+        case 'Grid':
+          this.createComponentSchema(subject, 'Grid');
+          break;
+      }
+    }
+  }
+
+  private getComponentsToProcess(screen: { content: string }): string[] {
+    const componentsToProcess: string[] = [];
+    const subjectBasedComponents: string[] = ['Form', 'Grid'];
+
+    const importRegex = /import type \{([\s\S]*?)\} from ['"]\.\.\/\.\.\/components\/index\.js['"];?/;
+    const importMatches = importRegex.exec(screen.content);
+
+    if (importMatches?.[1]) {
+      const importedComponents = importMatches[1].split(',').map((component) => component.trim());
+      importedComponents.forEach((component) => {
+        if (subjectBasedComponents.includes(component)) {
+          componentsToProcess.push(component);
+        }
+      });
+    }
+
+    return componentsToProcess;
+  }
+
+  private getScreenContent(screenTypeId: string): string {
+    const screenFileName = this._namingHandler.formatPascalCaseName(screenTypeId);
+    const _filename = fileURLToPath(import.meta.url);
+    const _dirname = path.dirname(_filename);
+    const screenLocation = path.resolve(_dirname, '..', '..', 'test-artifacts/screens/');
+
+    return fs.readFileSync(path.join(screenLocation, `I${screenFileName}.ts`), 'utf-8');
+  }
+
+  private createComponentSchema(subject: ISubject, componentType: SubjectComponents): void {
+    const interfaceName = `${subject.subject}_${componentType.toLowerCase()}`;
+    const schemasDir = path.join(currentDirname, '..', '..', 'dist/test-artifacts/schemas');
+    const fileName = `${this._namingHandler.snakeToPascalCase(interfaceName)}.json`;
+
+    if (fs.existsSync(path.join(schemasDir, fileName))) {
+      return;
+    }
+
+    // biome-ignore lint/suspicious/noExplicitAny: reason 42
+    const componentSchema: any = {
+      title: interfaceName,
+      type: 'object',
+      properties: {},
+      required: [],
+      additionalProperties: false,
+      definitions: {
+        Locator: {
+          type: 'object',
+          properties: {
+            selector: { type: 'string' }
+          },
+          required: ['selector'],
+          additionalProperties: false
+        }
+      }
+    };
+
+    subject.properties.forEach((property) => {
+      const componentTypeSuffix = this._namingHandler.getElementSuffixFromControlTypeAndComponentType(
+        property.control_type,
+        componentType
+      );
+      const fieldName = `${property.col}_${componentTypeSuffix.toLocaleLowerCase()}`;
+
+      componentSchema.properties[fieldName] = { $ref: '#/definitions/Locator' };
+      componentSchema.required.push(fieldName);
+    });
+
+    if (!fs.existsSync(schemasDir)) {
+      fs.mkdirSync(schemasDir, { recursive: true });
+    }
+
+    fs.writeFileSync(path.join(schemasDir, fileName), JSON.stringify(componentSchema, null, 2));
+  }
+}