@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/infrastructure/storage/schema-validating-workflow-storage.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidatingWorkflowStorage = void 0;
+exports.SchemaValidatingCompositeWorkflowStorage = exports.SchemaValidatingWorkflowStorage = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const ajv_1 = __importDefault(require("ajv"));
@@ -11,37 +11,46 @@ const error_handler_1 = require("../../core/error-handler");
 class SchemaValidatingWorkflowStorage {
     constructor(inner) {
         this.inner = inner;
+        this.kind = 'single';
         const schemaPath = path_1.default.resolve(__dirname, '../../../spec/workflow.schema.json');
         const schema = JSON.parse(fs_1.default.readFileSync(schemaPath, 'utf-8'));
         const ajv = new ajv_1.default({ allErrors: true, strict: false });
         this.validator = ajv.compile(schema);
     }
-    ensureValid(workflow) {
-        const isValid = this.validator(workflow);
+    get source() {
+        return this.inner.source;
+    }
+    validateDefinition(definition) {
+        const isValid = this.validator(definition);
         if (!isValid) {
-            throw new error_handler_1.InvalidWorkflowError(workflow.id ?? 'unknown', JSON.stringify(this.validator.errors));
+            const id = definition.id ?? 'unknown';
+            throw new error_handler_1.InvalidWorkflowError(id, JSON.stringify(this.validator.errors));
         }
         return true;
     }
     async loadAllWorkflows() {
-        const raw = await this.inner.loadAllWorkflows();
-        return raw.filter((wf) => {
+        const workflows = await this.inner.loadAllWorkflows();
+        const validWorkflows = [];
+        for (const workflow of workflows) {
             try {
-                return this.ensureValid(wf);
+                if (this.validateDefinition(workflow.definition)) {
+                    validWorkflows.push(workflow);
+                }
             }
             catch (err) {
-                console.error(`[SchemaValidation] Workflow '${wf.id}' failed validation:`, err instanceof Error ? err.message : err);
-                return false;
+                console.error(`[SchemaValidation] Workflow '${workflow.definition.id}' failed validation:`, err instanceof Error ? err.message : err);
             }
-        });
+        }
+        return validWorkflows;
     }
     async getWorkflowById(id) {
-        const wf = await this.inner.getWorkflowById(id);
-        if (!wf)
+        const workflow = await this.inner.getWorkflowById(id);
+        if (!workflow) {
             return null;
+        }
         try {
-            this.ensureValid(wf);
-            return wf;
+            this.validateDefinition(workflow.definition);
+            return workflow;
         }
         catch (err) {
             console.error(`[SchemaValidation] Workflow '${id}' failed validation:`, err instanceof Error ? err.message : err);
@@ -49,19 +58,72 @@ class SchemaValidatingWorkflowStorage {
         }
     }
     async listWorkflowSummaries() {
-        const workflows = await this.loadAllWorkflows();
-        return workflows.map((wf) => ({
-            id: wf.id,
-            name: wf.name,
-            description: wf.description,
-            category: 'default',
-            version: wf.version
-        }));
+        return this.inner.listWorkflowSummaries();
     }
-    async save(workflow) {
+    async save(definition) {
+        this.validateDefinition(definition);
         if (typeof this.inner.save === 'function') {
-            return this.inner.save(workflow);
+            return this.inner.save(definition);
         }
     }
 }
 exports.SchemaValidatingWorkflowStorage = SchemaValidatingWorkflowStorage;
+class SchemaValidatingCompositeWorkflowStorage {
+    constructor(inner) {
+        this.inner = inner;
+        this.kind = 'composite';
+        const schemaPath = path_1.default.resolve(__dirname, '../../../spec/workflow.schema.json');
+        const schema = JSON.parse(fs_1.default.readFileSync(schemaPath, 'utf-8'));
+        const ajv = new ajv_1.default({ allErrors: true, strict: false });
+        this.validator = ajv.compile(schema);
+    }
+    validateDefinition(definition) {
+        const isValid = this.validator(definition);
+        if (!isValid) {
+            const id = definition.id ?? 'unknown';
+            throw new error_handler_1.InvalidWorkflowError(id, JSON.stringify(this.validator.errors));
+        }
+        return true;
+    }
+    getSources() {
+        return this.inner.getSources();
+    }
+    async loadAllWorkflows() {
+        const workflows = await this.inner.loadAllWorkflows();
+        const validWorkflows = [];
+        for (const workflow of workflows) {
+            try {
+                if (this.validateDefinition(workflow.definition)) {
+                    validWorkflows.push(workflow);
+                }
+            }
+            catch (err) {
+                console.error(`[SchemaValidation] Workflow '${workflow.definition.id}' failed validation:`, err instanceof Error ? err.message : err);
+            }
+        }
+        return validWorkflows;
+    }
+    async getWorkflowById(id) {
+        const workflow = await this.inner.getWorkflowById(id);
+        if (!workflow)
+            return null;
+        try {
+            this.validateDefinition(workflow.definition);
+            return workflow;
+        }
+        catch (err) {
+            console.error(`[SchemaValidation] Workflow '${id}' failed validation:`, err instanceof Error ? err.message : err);
+            return null;
+        }
+    }
+    async listWorkflowSummaries() {
+        return this.inner.listWorkflowSummaries();
+    }
+    async save(definition) {
+        this.validateDefinition(definition);
+        if (typeof this.inner.save === 'function') {
+            return this.inner.save(definition);
+        }
+    }
+}
+exports.SchemaValidatingCompositeWorkflowStorage = SchemaValidatingCompositeWorkflowStorage;

package/dist/infrastructure/storage/storage.d.ts

@@ -1,7 +1,9 @@
 import { FileWorkflowStorage } from './file-workflow-storage';
-import { SchemaValidatingWorkflowStorage } from './schema-validating-workflow-storage';
-import { CachingWorkflowStorage } from './caching-workflow-storage';
-import { MultiDirectoryWorkflowStorage, createMultiDirectoryWorkflowStorage } from './multi-directory-workflow-storage';
-export declare function createDefaultWorkflowStorage(): CachingWorkflowStorage;
+import { SchemaValidatingWorkflowStorage, SchemaValidatingCompositeWorkflowStorage } from './schema-validating-workflow-storage';
+import { CachingWorkflowStorage, CachingCompositeWorkflowStorage } from './caching-workflow-storage';
+import { createEnhancedMultiSourceWorkflowStorage, EnhancedMultiSourceWorkflowStorage } from './enhanced-multi-source-workflow-storage';
+import { ICompositeWorkflowStorage } from '../../types/storage';
+export declare function createDefaultWorkflowStorage(): CachingCompositeWorkflowStorage;
 export declare function createLegacyWorkflowStorage(): CachingWorkflowStorage;
-export { FileWorkflowStorage, SchemaValidatingWorkflowStorage, CachingWorkflowStorage, MultiDirectoryWorkflowStorage, createMultiDirectoryWorkflowStorage };
+export { FileWorkflowStorage, SchemaValidatingWorkflowStorage, SchemaValidatingCompositeWorkflowStorage, CachingWorkflowStorage, CachingCompositeWorkflowStorage, EnhancedMultiSourceWorkflowStorage, createEnhancedMultiSourceWorkflowStorage };
+export type { ICompositeWorkflowStorage };

package/dist/infrastructure/storage/storage.js

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMultiDirectoryWorkflowStorage = exports.MultiDirectoryWorkflowStorage = exports.CachingWorkflowStorage = exports.SchemaValidatingWorkflowStorage = exports.FileWorkflowStorage = void 0;
+exports.createEnhancedMultiSourceWorkflowStorage = exports.EnhancedMultiSourceWorkflowStorage = exports.CachingCompositeWorkflowStorage = exports.CachingWorkflowStorage = exports.SchemaValidatingCompositeWorkflowStorage = exports.SchemaValidatingWorkflowStorage = exports.FileWorkflowStorage = void 0;
 exports.createDefaultWorkflowStorage = createDefaultWorkflowStorage;
 exports.createLegacyWorkflowStorage = createLegacyWorkflowStorage;
 const file_workflow_storage_1 = require("./file-workflow-storage");
 Object.defineProperty(exports, "FileWorkflowStorage", { enumerable: true, get: function () { return file_workflow_storage_1.FileWorkflowStorage; } });
 const schema_validating_workflow_storage_1 = require("./schema-validating-workflow-storage");
 Object.defineProperty(exports, "SchemaValidatingWorkflowStorage", { enumerable: true, get: function () { return schema_validating_workflow_storage_1.SchemaValidatingWorkflowStorage; } });
+Object.defineProperty(exports, "SchemaValidatingCompositeWorkflowStorage", { enumerable: true, get: function () { return schema_validating_workflow_storage_1.SchemaValidatingCompositeWorkflowStorage; } });
 const caching_workflow_storage_1 = require("./caching-workflow-storage");
 Object.defineProperty(exports, "CachingWorkflowStorage", { enumerable: true, get: function () { return caching_workflow_storage_1.CachingWorkflowStorage; } });
-const multi_directory_workflow_storage_1 = require("./multi-directory-workflow-storage");
-Object.defineProperty(exports, "MultiDirectoryWorkflowStorage", { enumerable: true, get: function () { return multi_directory_workflow_storage_1.MultiDirectoryWorkflowStorage; } });
-Object.defineProperty(exports, "createMultiDirectoryWorkflowStorage", { enumerable: true, get: function () { return multi_directory_workflow_storage_1.createMultiDirectoryWorkflowStorage; } });
+Object.defineProperty(exports, "CachingCompositeWorkflowStorage", { enumerable: true, get: function () { return caching_workflow_storage_1.CachingCompositeWorkflowStorage; } });
 const enhanced_multi_source_workflow_storage_1 = require("./enhanced-multi-source-workflow-storage");
+Object.defineProperty(exports, "createEnhancedMultiSourceWorkflowStorage", { enumerable: true, get: function () { return enhanced_multi_source_workflow_storage_1.createEnhancedMultiSourceWorkflowStorage; } });
+Object.defineProperty(exports, "EnhancedMultiSourceWorkflowStorage", { enumerable: true, get: function () { return enhanced_multi_source_workflow_storage_1.EnhancedMultiSourceWorkflowStorage; } });
 function createDefaultWorkflowStorage() {
     const baseStorage = (0, enhanced_multi_source_workflow_storage_1.createEnhancedMultiSourceWorkflowStorage)();
-    const validatingStorage = new schema_validating_workflow_storage_1.SchemaValidatingWorkflowStorage(baseStorage);
+    const validatingStorage = new schema_validating_workflow_storage_1.SchemaValidatingCompositeWorkflowStorage(baseStorage);
     const cacheTtlMs = Number(process.env['CACHE_TTL'] ?? 300000);
-    return new caching_workflow_storage_1.CachingWorkflowStorage(validatingStorage, cacheTtlMs);
+    return new caching_workflow_storage_1.CachingCompositeWorkflowStorage(validatingStorage, cacheTtlMs);
 }
 function createLegacyWorkflowStorage() {
     const baseStorage = (0, file_workflow_storage_1.createDefaultFileWorkflowStorage)();