@cxtms/cx-schema 1.0.0

package/schemas/workflows/trigger.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Workflow Trigger",
+  "description": "Definition of a workflow trigger",
+  "type": "object",
+  "properties": {
+    "type": {
+      "type": "string",
+      "enum": ["Manual", "Entity"],
+      "description": "Trigger type"
+    },
+    "displayName": {
+      "type": "string",
+      "description": "Display name for manual triggers (button text)"
+    },
+    "entityName": {
+      "type": "string",
+      "description": "Entity name for the trigger context"
+    },
+    "eventType": {
+      "type": "string",
+      "enum": ["Added", "Modified", "Deleted"],
+      "description": "Entity event type (for Entity triggers)"
+    },
+    "position": {
+      "type": "string",
+      "enum": ["Before", "After"],
+      "description": "When to execute relative to entity operation"
+    },
+    "conditions": {
+      "oneOf": [
+        {
+          "type": "string",
+          "description": "Single condition expression"
+        },
+        {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "expression": {
+                    "type": "string"
+                  }
+                },
+                "required": ["expression"]
+              }
+            ]
+          },
+          "description": "Array of condition expressions"
+        }
+      ],
+      "description": "Conditions for trigger activation"
+    },
+    "additionalProperties": {
+      "type": "object",
+      "description": "Additional trigger properties",
+      "properties": {
+        "silent": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "type": {
+            "const": "Entity"
+          }
+        },
+        "required": ["type"]
+      },
+      "then": {
+        "required": ["entityName", "eventType"]
+      }
+    }
+  ],
+  "additionalProperties": true
+}

package/schemas/workflows/variable.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Workflow Variable",
+  "description": "Definition of a workflow variable",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
+      "description": "Variable name"
+    },
+    "value": {
+      "description": "Static variable value or template expression"
+    },
+    "fromConfig": {
+      "oneOf": [
+        {
+          "type": "string",
+          "description": "Configuration key to load value from"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "configName": {
+              "type": "string",
+              "description": "Configuration name (e.g., 'apps.novaposhta')"
+            },
+            "key": {
+              "type": "string",
+              "description": "Optional key within configuration"
+            }
+          },
+          "required": ["configName"],
+          "additionalProperties": true
+        }
+      ],
+      "description": "Load value from configuration"
+    },
+    "expression": {
+      "type": "string",
+      "description": "NCalc expression to compute value"
+    }
+  },
+  "required": ["name"],
+  "additionalProperties": true
+}

package/schemas/workflows/workflow.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "CargoXplorer Workflow",
+  "description": "Schema for CargoXplorer workflow YAML files",
+  "type": "object",
+  "properties": {
+    "workflow": {
+      "type": "object",
+      "description": "Workflow metadata and configuration",
+      "properties": {
+        "workflowId": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Unique workflow identifier (UUID)"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Workflow name"
+        },
+        "description": {
+          "type": "string",
+          "description": "Workflow description"
+        },
+        "version": {
+          "type": "string",
+          "description": "Workflow version (e.g., '1.0')"
+        },
+        "executionMode": {
+          "type": "string",
+          "enum": ["Sync", "Async"],
+          "description": "Execution mode - synchronous or asynchronous"
+        },
+        "logLevel": {
+          "type": "string",
+          "enum": ["None", "Trace", "Debug", "Information", "Warning", "Error"],
+          "description": "Logging level for workflow execution"
+        },
+        "isActive": {
+          "type": "boolean",
+          "description": "Whether the workflow is active"
+        },
+        "enableAudit": {
+          "type": "boolean",
+          "description": "Enable audit logging"
+        },
+        "enableTransaction": {
+          "type": "boolean",
+          "description": "Enable transaction support"
+        },
+        "enableActionEvents": {
+          "type": "boolean",
+          "description": "Enable action events"
+        },
+        "priority": {
+          "type": "number",
+          "description": "Workflow priority (higher = higher priority)"
+        },
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Tags for categorization and filtering"
+        },
+        "workflowType": {
+          "type": "string",
+          "enum": ["Document", "Quote", "EmailTemplate"],
+          "description": "Workflow type classification"
+        },
+        "runAs": {
+          "type": "string",
+          "description": "User context for workflow execution"
+        },
+        "concurrency": {
+          "type": "object",
+          "properties": {
+            "group": {
+              "type": "string",
+              "description": "Concurrency group identifier"
+            },
+            "waitTime": {
+              "type": "number",
+              "description": "Seconds to wait for lock"
+            }
+          },
+          "additionalProperties": true
+        },
+        "fileName": {
+          "type": "string",
+          "description": "Path to the workflow YAML file"
+        },
+        "actionEvent": {
+          "type": "object",
+          "description": "Workflow action event configuration",
+          "additionalProperties": true
+        },
+        "additionalProperties": {
+          "type": "object",
+          "description": "Custom additional properties",
+          "additionalProperties": true
+        }
+      },
+      "required": ["workflowId", "name"],
+      "additionalProperties": true
+    },
+    "inputs": {
+      "type": ["array", "null"],
+      "description": "Workflow input parameters",
+      "items": {
+        "$ref": "input.json"
+      }
+    },
+    "outputs": {
+      "type": ["array", "null"],
+      "description": "Workflow output definitions",
+      "items": {
+        "$ref": "output.json"
+      }
+    },
+    "variables": {
+      "type": ["array", "null"],
+      "description": "Workflow variables",
+      "items": {
+        "$ref": "variable.json"
+      }
+    },
+    "activities": {
+      "type": "array",
+      "description": "Workflow activities containing steps",
+      "items": {
+        "$ref": "activity.json"
+      },
+      "minItems": 1
+    },
+    "triggers": {
+      "type": "array",
+      "description": "Workflow triggers",
+      "items": {
+        "$ref": "trigger.json"
+      }
+    },
+    "schedules": {
+      "type": "array",
+      "description": "Scheduled execution configurations",
+      "items": {
+        "$ref": "schedule.json"
+      }
+    },
+    "events": {
+      "type": "object",
+      "description": "Workflow-level event handlers",
+      "properties": {
+        "onWorkflowStarted": {
+          "type": "array",
+          "description": "Steps to execute when workflow starts"
+        },
+        "onWorkflowExecuted": {
+          "type": "array",
+          "description": "Steps to execute when workflow completes"
+        },
+        "onWorkflowFailed": {
+          "type": "array",
+          "description": "Steps to execute when workflow fails"
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "required": ["workflow", "activities"],
+  "additionalProperties": true
+}

package/scripts/postinstall.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script to create .cx-schema folder in the project root
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function findProjectRoot() {
+  let currentDir = process.cwd();
+
+  // Walk up the directory tree to find package.json
+  while (currentDir !== path.dirname(currentDir)) {
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      // Check if this is not the cx-schema-validator package itself
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        if (packageJson.name !== 'cx-schema-validator') {
+          return currentDir;
+        }
+      } catch (error) {
+        // Continue searching
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}
+
+function copyDirectory(src, dest) {
+  // Create destination directory if it doesn't exist
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  // Read directory contents
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function createValidationScript(projectRoot) {
+  const scriptContent = `#!/usr/bin/env node
+
+/**
+ * Local validation script
+ * This script uses the schemas in .cx-schema to validate modules
+ */
+
+const { ModuleValidator } = require('cx-schema-validator');
+const path = require('path');
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error('Usage: node .cx-schema/validate.js <module-file>');
+    process.exit(1);
+  }
+
+  const schemasPath = path.join(__dirname);
+  const validator = new ModuleValidator({ schemasPath });
+
+  for (const file of args) {
+    const result = await validator.validateModule(file);
+
+    console.log(\`\\nValidation result for \${file}:\`);
+    console.log(\`  Status: \${result.summary.status}\`);
+    console.log(\`  Errors: \${result.summary.errorCount}\`);
+    console.log(\`  Warnings: \${result.summary.warningCount}\`);
+
+    if (!result.isValid) {
+      console.log('\\nErrors:');
+      result.errors.forEach((error, index) => {
+        console.log(\`  [\${index + 1}] \${error.type}: \${error.message}\`);
+        console.log(\`      Path: \${error.path}\`);
+      });
+      process.exit(1);
+    }
+  }
+
+  console.log('\\nAll validations passed!');
+}
+
+main().catch(error => {
+  console.error('Error:', error);
+  process.exit(1);
+});
+`;
+
+  const scriptPath = path.join(projectRoot, '.cx-schema', 'validate.js');
+  fs.writeFileSync(scriptPath, scriptContent, 'utf-8');
+
+  // Make it executable on Unix-like systems
+  try {
+    fs.chmodSync(scriptPath, '755');
+  } catch (error) {
+    // Ignore chmod errors on Windows
+  }
+}
+
+function main() {
+  console.log('CX Schema Validator: Running postinstall...');
+
+  // Find project root
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log('Warning: Could not find project root. Skipping .cx-schema creation.');
+    return;
+  }
+
+  console.log(`Project root: ${projectRoot}`);
+
+  // Create .cx-schema directory
+  const cxSchemaDir = path.join(projectRoot, '.cx-schema');
+
+  if (fs.existsSync(cxSchemaDir)) {
+    console.log('.cx-schema directory already exists. Updating schemas...');
+  } else {
+    console.log('Creating .cx-schema directory...');
+    fs.mkdirSync(cxSchemaDir, { recursive: true });
+  }
+
+  // Copy schemas
+  const schemasSource = path.join(__dirname, '..', 'schemas');
+  console.log(`Copying schemas from ${schemasSource}...`);
+
+  try {
+    copyDirectory(schemasSource, cxSchemaDir);
+    console.log('Schemas copied successfully!');
+  } catch (error) {
+    console.error('Error copying schemas:', error.message);
+    process.exit(1);
+  }
+
+  // Create validation script
+  console.log('Creating validation script...');
+  createValidationScript(projectRoot);
+
+  console.log('✓ CX Schema Validator installed successfully!');
+  console.log('\nUsage:');
+  console.log('  npx cx-validate modules/your-module.yaml');
+  console.log('  node .cx-schema/validate.js modules/your-module.yaml');
+}
+
+// Only run if this is not being installed as a dependency of cx-schema-validator itself
+if (!process.env.npm_package_name || process.env.npm_package_name !== 'cx-schema-validator') {
+  main();
+}

package/scripts/setup-vscode.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+/**
+ * VS Code integration setup script
+ * Creates .vscode/settings.json with YAML schema associations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function setupVSCode(projectRoot) {
+  const vscodeDir = path.join(projectRoot, '.vscode');
+  const settingsPath = path.join(vscodeDir, 'settings.json');
+
+  // Create .vscode directory if it doesn't exist
+  if (!fs.existsSync(vscodeDir)) {
+    fs.mkdirSync(vscodeDir, { recursive: true });
+    console.log('Created .vscode directory');
+  }
+
+  // Read existing settings or create new
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const content = fs.readFileSync(settingsPath, 'utf-8');
+      settings = JSON.parse(content);
+      console.log('Loaded existing VS Code settings');
+    } catch (error) {
+      console.warn('Could not parse existing settings.json, creating new one');
+    }
+  }
+
+  // Add or update YAML schema associations
+  if (!settings['yaml.schemas']) {
+    settings['yaml.schemas'] = {};
+  }
+
+  // Add schema mapping for module files
+  const schemaPath = path.join(projectRoot, '.cx-schema', 'schemas.json');
+  settings['yaml.schemas'][schemaPath] = [
+    'modules/*-module.yaml',
+    'modules/**/*-module.yaml'
+  ];
+
+  // Write updated settings
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+  console.log('Updated .vscode/settings.json with schema associations');
+
+  return true;
+}
+
+function main() {
+  const projectRoot = process.cwd();
+
+  console.log('Setting up VS Code integration...');
+  console.log(`Project root: ${projectRoot}`);
+
+  if (!fs.existsSync(path.join(projectRoot, '.cx-schema'))) {
+    console.error('Error: .cx-schema directory not found.');
+    console.error('Please run npm install first to create the schema directory.');
+    process.exit(1);
+  }
+
+  try {
+    setupVSCode(projectRoot);
+    console.log('\n✓ VS Code integration setup complete!');
+    console.log('\nYour YAML module files will now have schema validation and autocomplete in VS Code.');
+    console.log('Restart VS Code for changes to take effect.');
+  } catch (error) {
+    console.error('Error setting up VS Code integration:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { setupVSCode };

package/templates/module.yaml

@@ -0,0 +1,83 @@
+# {{displayName}} Module
+# Generated by cx-validate create module
+
+module:
+  name: "{{name}}"
+  appModuleId: "{{uuid}}"
+  displayName: "{{displayName}}"
+  description: "{{displayName}} module"
+  icon: "folder"
+  version: "1.0"
+  fileName: "{{fileName}}"
+
+entities:
+  - name: {{name}}
+    displayName: "{{displayName}}"
+
+permissions:
+  - name: "view-{{name}}"
+    displayName: "View {{displayName}}"
+  - name: "edit-{{name}}"
+    displayName: "Edit {{displayName}}"
+
+routes:
+  - name: "list"
+    path: "/{{name}}"
+    component: list
+  - name: "detail"
+    path: "/{{name}}/:id"
+    component: detail
+
+components:
+  - type: layout
+    name: list
+    title: "{{displayName}} List"
+    children:
+      - type: dataGrid
+        name: {{name}}Grid
+        props:
+          entityName: "{{name}}"
+          columns:
+            - field: "name"
+              headerName: "Name"
+              flex: 1
+            - field: "createdAt"
+              headerName: "Created"
+              type: "date"
+        actions:
+          onRowClick:
+            - type: navigate
+              props:
+                route: "detail"
+                params:
+                  id: "{{row.id}}"
+
+  - type: layout
+    name: detail
+    title: "{{displayName}} Detail"
+    children:
+      - type: form
+        name: {{name}}Form
+        props:
+          entityName: "{{name}}"
+        fields:
+          - type: text
+            name: name
+            props:
+              label: "Name"
+              required: true
+          - type: textarea
+            name: description
+            props:
+              label: "Description"
+              rows: 3
+        actions:
+          onSubmit:
+            - type: mutation
+              props:
+                operation: "update{{displayNameNoSpaces}}"
+                input: "{{form}}"
+            - type: notification
+              props:
+                message: "{{displayName}} saved successfully"
+                severity: "success"