create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

package/templates/default/src/lib/sync/sync-registry.ts

@@ -0,0 +1,149 @@
+type BaseSyncScriptDefinition = {
+  id: string
+  label: string
+  description: string
+  orderLabel: string
+  scriptFile: string
+  dependencies: string[]
+}
+
+export const SYNC_ALL_REQUEST_ID = 'sync-all' as const
+
+export const syncScriptDefinitions = [
+  {
+    id: 'sync-modules',
+    label: 'Sync Modules',
+    description: 'Syncs modules to DB.',
+    orderLabel: 'Modules',
+    scriptFile: 'sync-modules.ts',
+    dependencies: [],
+  },
+  {
+    id: 'sync-environments',
+    label: 'Sync Environments',
+    description: 'Syncs environments to DB.',
+    orderLabel: 'Environments',
+    scriptFile: 'sync-environments.ts',
+    dependencies: [],
+  },
+  {
+    id: 'sync-tags',
+    label: 'Sync Tags',
+    description: 'Syncs tags to DB.',
+    orderLabel: 'Tags',
+    scriptFile: 'sync-tags.ts',
+    dependencies: [],
+  },
+  {
+    id: 'sync-template-step-groups',
+    label: 'Sync Template Step Groups',
+    description: 'Syncs template step groups to DB.',
+    orderLabel: 'Template Step Groups',
+    scriptFile: 'sync-template-step-groups.ts',
+    dependencies: [],
+  },
+  {
+    id: 'sync-template-steps',
+    label: 'Sync Template Steps',
+    description: 'Syncs template steps to DB.',
+    orderLabel: 'Template Steps',
+    scriptFile: 'sync-template-steps.ts',
+    dependencies: ['sync-template-step-groups'],
+  },
+  {
+    id: 'sync-locator-groups',
+    label: 'Sync Locator Groups',
+    description: 'Syncs locator groups to DB.',
+    orderLabel: 'Locator Groups',
+    scriptFile: 'sync-locator-groups.ts',
+    dependencies: ['sync-modules'],
+  },
+  {
+    id: 'sync-locators',
+    label: 'Sync Locators',
+    description: 'Syncs locators to DB.',
+    orderLabel: 'Locators',
+    scriptFile: 'sync-locators.ts',
+    dependencies: ['sync-locator-groups'],
+  },
+  {
+    id: 'sync-test-suites',
+    label: 'Sync Test Suites',
+    description: 'Syncs test suites to DB.',
+    orderLabel: 'Test Suites',
+    scriptFile: 'sync-test-suites.ts',
+    dependencies: ['sync-modules', 'sync-tags'],
+  },
+  {
+    id: 'sync-test-cases',
+    label: 'Sync Test Cases',
+    description: 'Syncs test cases to DB.',
+    orderLabel: 'Test Cases',
+    scriptFile: 'sync-test-cases.ts',
+    dependencies: ['sync-test-suites', 'sync-template-steps', 'sync-tags'],
+  },
+] as const satisfies readonly BaseSyncScriptDefinition[]
+
+export type SyncScriptId = (typeof syncScriptDefinitions)[number]['id']
+export type SyncRequestId = SyncScriptId | typeof SYNC_ALL_REQUEST_ID
+export type SyncScriptDefinition = (typeof syncScriptDefinitions)[number]
+
+const syncScriptDefinitionMap = new Map<SyncScriptId, (typeof syncScriptDefinitions)[number]>(
+  syncScriptDefinitions.map(definition => [definition.id, definition]),
+)
+
+export function isSyncScriptId(value: string): value is SyncScriptId {
+  return syncScriptDefinitionMap.has(value as SyncScriptId)
+}
+
+export function isSyncRequestId(value: string): value is SyncRequestId {
+  return value === SYNC_ALL_REQUEST_ID || isSyncScriptId(value)
+}
+
+export function getSyncScriptDefinition(scriptId: SyncScriptId) {
+  const definition = syncScriptDefinitionMap.get(scriptId)
+
+  if (!definition) {
+    throw new Error(`Unknown sync script: ${scriptId}`)
+  }
+
+  return definition
+}
+
+export function resolveSyncExecutionOrder(requestedScriptId: SyncScriptId): SyncScriptId[] {
+  const visiting = new Set<SyncScriptId>()
+  const visited = new Set<SyncScriptId>()
+  const executionOrder: SyncScriptId[] = []
+
+  const visit = (scriptId: SyncScriptId) => {
+    if (visited.has(scriptId)) {
+      return
+    }
+
+    if (visiting.has(scriptId)) {
+      throw new Error(`Circular sync dependency detected for ${scriptId}`)
+    }
+
+    visiting.add(scriptId)
+
+    for (const dependencyId of getSyncScriptDefinition(scriptId).dependencies) {
+      visit(dependencyId as SyncScriptId)
+    }
+
+    visiting.delete(scriptId)
+    visited.add(scriptId)
+    executionOrder.push(scriptId)
+  }
+
+  visit(requestedScriptId)
+
+  return executionOrder
+}
+
+export function resolveRequestedSyncExecutionOrder(requestedScriptId: SyncRequestId): SyncScriptId[] {
+  if (requestedScriptId === SYNC_ALL_REQUEST_ID) {
+    return syncScriptDefinitions.map(definition => definition.id)
+  }
+
+  return resolveSyncExecutionOrder(requestedScriptId)
+}

package/templates/default/src/lib/tag-utils.ts

@@ -0,0 +1,28 @@
+import { Tag, TagType } from '@prisma/client'
+
+type TagShape = Pick<Tag, 'name' | 'tagExpression' | 'type'>
+
+export function isIdentifierTagName(name: string): boolean {
+  return name.startsWith('tc_') || name.startsWith('ts_')
+}
+
+export function isIdentifierTagExpression(tagExpression: string): boolean {
+  const normalized = tagExpression.startsWith('@') ? tagExpression.slice(1) : tagExpression
+  return isIdentifierTagName(normalized)
+}
+
+export function getTagTypeFromName(name: string): TagType {
+  return isIdentifierTagName(name) ? TagType.IDENTIFIER : TagType.FILTER
+}
+
+export function getTagTypeFromExpression(tagExpression: string): TagType {
+  return isIdentifierTagExpression(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
+}
+
+export function getIdentifierTagByPrefix<T extends TagShape>(tags: T[], prefix: 'tc_' | 'ts_'): T | undefined {
+  return tags.find(tag => tag.type === TagType.IDENTIFIER && tag.name.startsWith(prefix))
+}
+
+export function getFilterTags<T extends TagShape>(tags: T[]): T[] {
+  return tags.filter(tag => tag.type === TagType.FILTER)
+}

package/templates/default/src/lib/template-sync-utils.d.ts

@@ -1,7 +1,7 @@
-export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
-export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
-export declare function getAutomationFeaturesDir(baseDir: string): string;
-export declare function getAutomationLocatorsDir(baseDir: string): string;
-export declare function getAutomationLocatorMapPath(baseDir: string): string;
-export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
+export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
+export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
+export declare function getAutomationFeaturesDir(baseDir: string): string;
+export declare function getAutomationLocatorsDir(baseDir: string): string;
+export declare function getAutomationLocatorMapPath(baseDir: string): string;
+export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
 //# sourceMappingURL=template-sync-utils.d.ts.map

package/templates/default/src/lib/template-sync-utils.js

@@ -1,47 +1,47 @@
-import { join, relative } from 'path';
-const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist']);
-const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo']);
-const EXCLUDED_PATH_PREFIXES = ['automation/reports/'];
-function toPosixPath(value) {
-    return value.replace(/\\/g, '/');
-}
-export function shouldExcludeTemplatePath(relativePath) {
-    const normalizedPath = toPosixPath(relativePath);
-    const parts = normalizedPath.split('/');
-    if (parts.some(part => EXCLUDED_DIRS.has(part)))
-        return true;
-    if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix)))
-        return true;
-    const ext = normalizedPath.endsWith('.sqlite3')
-        ? '.sqlite3'
-        : normalizedPath.endsWith('.sqlite')
-            ? '.sqlite'
-            : normalizedPath.endsWith('.tsbuildinfo')
-                ? '.tsbuildinfo'
-                : normalizedPath.slice(normalizedPath.lastIndexOf('.'));
-    return EXCLUDED_EXTENSIONS.has(ext);
-}
-export function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile, legacyEnvironmentsDirExists) {
-    return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists;
-}
-export function getAutomationFeaturesDir(baseDir) {
-    return join(baseDir, 'automation', 'features');
-}
-export function getAutomationLocatorsDir(baseDir) {
-    return join(baseDir, 'automation', 'locators');
-}
-export function getAutomationLocatorMapPath(baseDir) {
-    return join(baseDir, 'automation', 'mapping', 'locator-map.json');
-}
-export function extractModulePathFromAutomationFile(filePath, baseDir, automationSubdir) {
-    const automationBaseDir = automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir);
-    const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '');
-    const normalizedFilePath = toPosixPath(filePath);
-    const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
-        ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
-        : toPosixPath(relative(automationBaseDir, filePath));
-    const pathParts = relativePath.split('/').filter(part => part && part !== '');
-    const moduleParts = pathParts.slice(0, -1);
-    return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/';
-}
+import { join, relative } from 'path';
+const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist']);
+const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo']);
+const EXCLUDED_PATH_PREFIXES = ['automation/reports/'];
+function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}
+export function shouldExcludeTemplatePath(relativePath) {
+    const normalizedPath = toPosixPath(relativePath);
+    const parts = normalizedPath.split('/');
+    if (parts.some(part => EXCLUDED_DIRS.has(part)))
+        return true;
+    if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix)))
+        return true;
+    const ext = normalizedPath.endsWith('.sqlite3')
+        ? '.sqlite3'
+        : normalizedPath.endsWith('.sqlite')
+            ? '.sqlite'
+            : normalizedPath.endsWith('.tsbuildinfo')
+                ? '.tsbuildinfo'
+                : normalizedPath.slice(normalizedPath.lastIndexOf('.'));
+    return EXCLUDED_EXTENSIONS.has(ext);
+}
+export function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile, legacyEnvironmentsDirExists) {
+    return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists;
+}
+export function getAutomationFeaturesDir(baseDir) {
+    return join(baseDir, 'automation', 'features');
+}
+export function getAutomationLocatorsDir(baseDir) {
+    return join(baseDir, 'automation', 'locators');
+}
+export function getAutomationLocatorMapPath(baseDir) {
+    return join(baseDir, 'automation', 'mapping', 'locator-map.json');
+}
+export function extractModulePathFromAutomationFile(filePath, baseDir, automationSubdir) {
+    const automationBaseDir = automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir);
+    const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '');
+    const normalizedFilePath = toPosixPath(filePath);
+    const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
+        ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
+        : toPosixPath(relative(automationBaseDir, filePath));
+    const pathParts = relativePath.split('/').filter(part => part && part !== '');
+    const moduleParts = pathParts.slice(0, -1);
+    return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/';
+}
 //# sourceMappingURL=template-sync-utils.js.map

package/templates/default/src/lib/template-sync-utils.ts

@@ -1,63 +1,63 @@
-import { join, relative } from 'path'
-
-const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
-const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
-const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
-
-function toPosixPath(value: string): string {
-  return value.replace(/\\/g, '/')
-}
-
-export function shouldExcludeTemplatePath(relativePath: string): boolean {
-  const normalizedPath = toPosixPath(relativePath)
-  const parts = normalizedPath.split('/')
-
-  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
-  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
-
-  const ext = normalizedPath.endsWith('.sqlite3')
-    ? '.sqlite3'
-    : normalizedPath.endsWith('.sqlite')
-      ? '.sqlite'
-      : normalizedPath.endsWith('.tsbuildinfo')
-        ? '.tsbuildinfo'
-        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
-
-  return EXCLUDED_EXTENSIONS.has(ext)
-}
-
-export function shouldBackfillLegacyEnvironmentConfig(
-  targetHasEnvironmentsFile: boolean,
-  legacyEnvironmentsDirExists: boolean,
-): boolean {
-  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
-}
-
-export function getAutomationFeaturesDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'features')
-}
-
-export function getAutomationLocatorsDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'locators')
-}
-
-export function getAutomationLocatorMapPath(baseDir: string): string {
-  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
-}
-
-export function extractModulePathFromAutomationFile(
-  filePath: string,
-  baseDir: string,
-  automationSubdir: 'features' | 'locators',
-): string {
-  const automationBaseDir =
-    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
-  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
-  const normalizedFilePath = toPosixPath(filePath)
-  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
-    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
-    : toPosixPath(relative(automationBaseDir, filePath))
-  const pathParts = relativePath.split('/').filter(part => part && part !== '')
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
-}
+import { join, relative } from 'path'
+
+const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
+const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
+const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
+
+function toPosixPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+export function shouldExcludeTemplatePath(relativePath: string): boolean {
+  const normalizedPath = toPosixPath(relativePath)
+  const parts = normalizedPath.split('/')
+
+  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
+  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
+
+  const ext = normalizedPath.endsWith('.sqlite3')
+    ? '.sqlite3'
+    : normalizedPath.endsWith('.sqlite')
+      ? '.sqlite'
+      : normalizedPath.endsWith('.tsbuildinfo')
+        ? '.tsbuildinfo'
+        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
+
+  return EXCLUDED_EXTENSIONS.has(ext)
+}
+
+export function shouldBackfillLegacyEnvironmentConfig(
+  targetHasEnvironmentsFile: boolean,
+  legacyEnvironmentsDirExists: boolean,
+): boolean {
+  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
+}
+
+export function getAutomationFeaturesDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'features')
+}
+
+export function getAutomationLocatorsDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'locators')
+}
+
+export function getAutomationLocatorMapPath(baseDir: string): string {
+  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
+}
+
+export function extractModulePathFromAutomationFile(
+  filePath: string,
+  baseDir: string,
+  automationSubdir: 'features' | 'locators',
+): string {
+  const automationBaseDir =
+    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
+  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
+  const normalizedFilePath = toPosixPath(filePath)
+  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
+    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
+    : toPosixPath(relative(automationBaseDir, filePath))
+  const pathParts = relativePath.split('/').filter(part => part && part !== '')
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
+}

package/templates/default/src/lib/test-case-utils.ts

@@ -1,6 +1,6 @@
-import crypto from 'crypto'
-
-export function generateUniqueTestCaseIdentifier(): string {
-  const id = crypto.randomBytes(8).toString('hex')
-  return `tc_${id}`
-}
+import crypto from 'crypto'
+
+export function generateUniqueTestCaseIdentifier(): string {
+  const id = crypto.randomBytes(8).toString('hex')
+  return `tc_${id}`
+}

package/templates/default/src/lib/test-run/log-formatter.ts

@@ -1,83 +1,83 @@
-/**
- * Log formatting utilities for storing and retrieving test run logs
- */
-
-export interface LogEntry {
-  type: 'stdout' | 'stderr' | 'status'
-  message: string
-  timestamp: Date
-}
-
-/**
- * Formats log entries into a single text string for storage in the database
- * Format: [timestamp] [TYPE] message
- * 
- * @param logs - Array of log entries to format
- * @returns Formatted log string
- */
-export function formatLogsForStorage(logs: LogEntry[]): string {
-  return logs
-    .map(log => {
-      const timestamp = log.timestamp.toISOString()
-      const type = log.type.toUpperCase()
-      // Escape newlines in message to preserve them in the formatted string
-      const escapedMessage = log.message.replace(/\n/g, '\\n')
-      return `[${timestamp}] [${type}] ${escapedMessage}`
-    })
-    .join('\n')
-}
-
-/**
- * Parses formatted log text back into an array of LogEntry objects
- * 
- * @param formattedLogs - Formatted log string from database
- * @returns Array of log entries
- */
-export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
-  if (!formattedLogs || formattedLogs.trim() === '') {
-    return []
-  }
-
-  const lines = formattedLogs.split('\n')
-  const parsedLogs: LogEntry[] = []
-
-  for (const line of lines) {
-    if (!line.trim()) continue
-
-    try {
-      // Match format: [timestamp] [TYPE] message
-      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
-      
-      if (match) {
-        const [, timestampStr, typeStr, message] = match
-        const timestamp = new Date(timestampStr)
-        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
-        
-        // Unescape newlines in message
-        const unescapedMessage = message.replace(/\\n/g, '\n')
-        
-        // Validate type
-        if (type === 'stdout' || type === 'stderr' || type === 'status') {
-          parsedLogs.push({
-            type,
-            message: unescapedMessage,
-            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
-          })
-        }
-      } else {
-        // Fallback: treat as stdout if format doesn't match
-        parsedLogs.push({
-          type: 'stdout',
-          message: line,
-          timestamp: new Date(),
-        })
-      }
-    } catch (error) {
-      // Skip malformed lines
-      console.error('[LogFormatter] Error parsing log line:', line, error)
-    }
-  }
-
-  return parsedLogs
-}
-
+/**
+ * Log formatting utilities for storing and retrieving test run logs
+ */
+
+export interface LogEntry {
+  type: 'stdout' | 'stderr' | 'status'
+  message: string
+  timestamp: Date
+}
+
+/**
+ * Formats log entries into a single text string for storage in the database
+ * Format: [timestamp] [TYPE] message
+ * 
+ * @param logs - Array of log entries to format
+ * @returns Formatted log string
+ */
+export function formatLogsForStorage(logs: LogEntry[]): string {
+  return logs
+    .map(log => {
+      const timestamp = log.timestamp.toISOString()
+      const type = log.type.toUpperCase()
+      // Escape newlines in message to preserve them in the formatted string
+      const escapedMessage = log.message.replace(/\n/g, '\\n')
+      return `[${timestamp}] [${type}] ${escapedMessage}`
+    })
+    .join('\n')
+}
+
+/**
+ * Parses formatted log text back into an array of LogEntry objects
+ * 
+ * @param formattedLogs - Formatted log string from database
+ * @returns Array of log entries
+ */
+export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
+  if (!formattedLogs || formattedLogs.trim() === '') {
+    return []
+  }
+
+  const lines = formattedLogs.split('\n')
+  const parsedLogs: LogEntry[] = []
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+
+    try {
+      // Match format: [timestamp] [TYPE] message
+      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
+      
+      if (match) {
+        const [, timestampStr, typeStr, message] = match
+        const timestamp = new Date(timestampStr)
+        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
+        
+        // Unescape newlines in message
+        const unescapedMessage = message.replace(/\\n/g, '\n')
+        
+        // Validate type
+        if (type === 'stdout' || type === 'stderr' || type === 'status') {
+          parsedLogs.push({
+            type,
+            message: unescapedMessage,
+            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
+          })
+        }
+      } else {
+        // Fallback: treat as stdout if format doesn't match
+        parsedLogs.push({
+          type: 'stdout',
+          message: line,
+          timestamp: new Date(),
+        })
+      }
+    } catch (error) {
+      // Skip malformed lines
+      console.error('[LogFormatter] Error parsing log line:', line, error)
+    }
+  }
+
+  return parsedLogs
+}
+