@objectstack/spec 0.9.0 → 0.9.2

package/dist/system/plugin-versioning.zod.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginVersionMetadataSchema = exports.MultiVersionSupportSchema = exports.DependencyResolutionResultSchema = exports.DependencyConflictSchema = exports.PluginCompatibilityMatrixSchema = exports.CompatibilityMatrixEntrySchema = exports.DeprecationNoticeSchema = exports.BreakingChangeSchema = exports.CompatibilityLevelSchema = exports.VersionConstraintSchema = exports.SemanticVersionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * # Plugin Versioning and Compatibility Protocol
+ *
+ * Defines comprehensive versioning, compatibility checking, and dependency
+ * resolution mechanisms for the plugin ecosystem.
+ *
+ * Based on semantic versioning (SemVer) with extensions for:
+ * - Compatibility matrices
+ * - Breaking change detection
+ * - Migration paths
+ * - Multi-version support
+ */
+/**
+ * Semantic Version Schema
+ * Standard SemVer format with optional pre-release and build metadata
+ */
+exports.SemanticVersionSchema = zod_1.z.object({
+    major: zod_1.z.number().int().min(0).describe('Major version (breaking changes)'),
+    minor: zod_1.z.number().int().min(0).describe('Minor version (backward compatible features)'),
+    patch: zod_1.z.number().int().min(0).describe('Patch version (backward compatible fixes)'),
+    preRelease: zod_1.z.string().optional().describe('Pre-release identifier (alpha, beta, rc.1)'),
+    build: zod_1.z.string().optional().describe('Build metadata'),
+}).describe('Semantic version number');
+/**
+ * Version Constraint Schema
+ * Defines version requirements using SemVer ranges
+ */
+exports.VersionConstraintSchema = zod_1.z.union([
+    zod_1.z.string().regex(/^[\d.]+$/).describe('Exact version: 1.2.3'),
+    zod_1.z.string().regex(/^\^[\d.]+$/).describe('Compatible with: ^1.2.3 (>=1.2.3 <2.0.0)'),
+    zod_1.z.string().regex(/^~[\d.]+$/).describe('Approximately: ~1.2.3 (>=1.2.3 <1.3.0)'),
+    zod_1.z.string().regex(/^>=[\d.]+$/).describe('Greater than or equal: >=1.2.3'),
+    zod_1.z.string().regex(/^>[\d.]+$/).describe('Greater than: >1.2.3'),
+    zod_1.z.string().regex(/^<=[\d.]+$/).describe('Less than or equal: <=1.2.3'),
+    zod_1.z.string().regex(/^<[\d.]+$/).describe('Less than: <1.2.3'),
+    zod_1.z.string().regex(/^[\d.]+ - [\d.]+$/).describe('Range: 1.2.3 - 2.3.4'),
+    zod_1.z.literal('*').describe('Any version'),
+    zod_1.z.literal('latest').describe('Latest stable version'),
+]);
+/**
+ * Compatibility Level
+ * Describes the level of compatibility between versions
+ */
+exports.CompatibilityLevelSchema = zod_1.z.enum([
+    'fully-compatible', // 100% compatible, drop-in replacement
+    'backward-compatible', // Backward compatible, new features added
+    'deprecated-compatible', // Compatible but uses deprecated features
+    'breaking-changes', // Breaking changes, migration required
+    'incompatible', // Completely incompatible
+]).describe('Compatibility level between versions');
+/**
+ * Breaking Change
+ * Documents a breaking change in a version
+ */
+exports.BreakingChangeSchema = zod_1.z.object({
+    /**
+     * Version where the change was introduced
+     */
+    introducedIn: zod_1.z.string().describe('Version that introduced this breaking change'),
+    /**
+     * Type of breaking change
+     */
+    type: zod_1.z.enum([
+        'api-removed', // API removed
+        'api-renamed', // API renamed
+        'api-signature-changed', // Function signature changed
+        'behavior-changed', // Behavior changed
+        'dependency-changed', // Dependency requirement changed
+        'configuration-changed', // Configuration schema changed
+        'protocol-changed', // Protocol implementation changed
+    ]),
+    /**
+     * What was changed
+     */
+    description: zod_1.z.string(),
+    /**
+     * Migration guide
+     */
+    migrationGuide: zod_1.z.string().optional().describe('How to migrate from old to new'),
+    /**
+     * Deprecated in version
+     */
+    deprecatedIn: zod_1.z.string().optional().describe('Version where old API was deprecated'),
+    /**
+     * Will be removed in version
+     */
+    removedIn: zod_1.z.string().optional().describe('Version where old API will be removed'),
+    /**
+     * Automated migration available
+     */
+    automatedMigration: zod_1.z.boolean().default(false)
+        .describe('Whether automated migration tool is available'),
+    /**
+     * Impact severity
+     */
+    severity: zod_1.z.enum(['critical', 'major', 'minor']).describe('Impact severity'),
+});
+/**
+ * Deprecation Notice
+ * Information about deprecated features
+ */
+exports.DeprecationNoticeSchema = zod_1.z.object({
+    /**
+     * Feature or API being deprecated
+     */
+    feature: zod_1.z.string().describe('Deprecated feature identifier'),
+    /**
+     * Version when deprecated
+     */
+    deprecatedIn: zod_1.z.string(),
+    /**
+     * Planned removal version
+     */
+    removeIn: zod_1.z.string().optional(),
+    /**
+     * Reason for deprecation
+     */
+    reason: zod_1.z.string(),
+    /**
+     * Recommended alternative
+     */
+    alternative: zod_1.z.string().optional().describe('What to use instead'),
+    /**
+     * Migration path
+     */
+    migrationPath: zod_1.z.string().optional().describe('How to migrate to alternative'),
+});
+/**
+ * Compatibility Matrix Entry
+ * Maps compatibility between different plugin versions
+ */
+exports.CompatibilityMatrixEntrySchema = zod_1.z.object({
+    /**
+     * Source version
+     */
+    from: zod_1.z.string().describe('Version being upgraded from'),
+    /**
+     * Target version
+     */
+    to: zod_1.z.string().describe('Version being upgraded to'),
+    /**
+     * Compatibility level
+     */
+    compatibility: exports.CompatibilityLevelSchema,
+    /**
+     * Breaking changes list
+     */
+    breakingChanges: zod_1.z.array(exports.BreakingChangeSchema).optional(),
+    /**
+     * Migration required
+     */
+    migrationRequired: zod_1.z.boolean().default(false),
+    /**
+     * Migration complexity
+     */
+    migrationComplexity: zod_1.z.enum(['trivial', 'simple', 'moderate', 'complex', 'major']).optional(),
+    /**
+     * Estimated migration time in hours
+     */
+    estimatedMigrationTime: zod_1.z.number().optional(),
+    /**
+     * Migration script available
+     */
+    migrationScript: zod_1.z.string().optional().describe('Path to migration script'),
+    /**
+     * Test coverage for migration
+     */
+    testCoverage: zod_1.z.number().min(0).max(100).optional()
+        .describe('Percentage of migration covered by tests'),
+});
+/**
+ * Plugin Compatibility Matrix
+ * Complete compatibility information for a plugin
+ */
+exports.PluginCompatibilityMatrixSchema = zod_1.z.object({
+    /**
+     * Plugin identifier
+     */
+    pluginId: zod_1.z.string(),
+    /**
+     * Current version
+     */
+    currentVersion: zod_1.z.string(),
+    /**
+     * Compatibility entries
+     */
+    compatibilityMatrix: zod_1.z.array(exports.CompatibilityMatrixEntrySchema),
+    /**
+     * Supported versions
+     */
+    supportedVersions: zod_1.z.array(zod_1.z.object({
+        version: zod_1.z.string(),
+        supported: zod_1.z.boolean(),
+        endOfLife: zod_1.z.string().datetime().optional().describe('End of support date'),
+        securitySupport: zod_1.z.boolean().default(false).describe('Still receives security updates'),
+    })),
+    /**
+     * Minimum compatible version
+     */
+    minimumCompatibleVersion: zod_1.z.string().optional()
+        .describe('Oldest version that can be directly upgraded'),
+});
+/**
+ * Dependency Conflict
+ * Represents a conflict in plugin dependencies
+ */
+exports.DependencyConflictSchema = zod_1.z.object({
+    /**
+     * Type of conflict
+     */
+    type: zod_1.z.enum([
+        'version-mismatch', // Different versions required
+        'missing-dependency', // Required dependency not found
+        'circular-dependency', // Circular dependency detected
+        'incompatible-versions', // Incompatible versions required by different plugins
+        'conflicting-interfaces', // Plugins implement conflicting interfaces
+    ]),
+    /**
+     * Plugins involved in conflict
+     */
+    plugins: zod_1.z.array(zod_1.z.object({
+        pluginId: zod_1.z.string(),
+        version: zod_1.z.string(),
+        requirement: zod_1.z.string().optional().describe('What this plugin requires'),
+    })),
+    /**
+     * Conflict description
+     */
+    description: zod_1.z.string(),
+    /**
+     * Possible resolutions
+     */
+    resolutions: zod_1.z.array(zod_1.z.object({
+        strategy: zod_1.z.enum([
+            'upgrade', // Upgrade one or more plugins
+            'downgrade', // Downgrade one or more plugins
+            'replace', // Replace with alternative plugin
+            'disable', // Disable conflicting plugin
+            'manual', // Manual intervention required
+        ]),
+        description: zod_1.z.string(),
+        automaticResolution: zod_1.z.boolean().default(false),
+        riskLevel: zod_1.z.enum(['low', 'medium', 'high']),
+    })).optional(),
+    /**
+     * Severity of conflict
+     */
+    severity: zod_1.z.enum(['critical', 'error', 'warning', 'info']),
+});
+/**
+ * Dependency Resolution Result
+ * Result of dependency resolution process
+ */
+exports.DependencyResolutionResultSchema = zod_1.z.object({
+    /**
+     * Resolution successful
+     */
+    success: zod_1.z.boolean(),
+    /**
+     * Resolved plugin versions
+     */
+    resolved: zod_1.z.array(zod_1.z.object({
+        pluginId: zod_1.z.string(),
+        version: zod_1.z.string(),
+        resolvedVersion: zod_1.z.string(),
+    })).optional(),
+    /**
+     * Conflicts found
+     */
+    conflicts: zod_1.z.array(exports.DependencyConflictSchema).optional(),
+    /**
+     * Warnings
+     */
+    warnings: zod_1.z.array(zod_1.z.string()).optional(),
+    /**
+     * Installation order (topologically sorted)
+     */
+    installationOrder: zod_1.z.array(zod_1.z.string()).optional()
+        .describe('Plugin IDs in order they should be installed'),
+    /**
+     * Dependency graph
+     */
+    dependencyGraph: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())).optional()
+        .describe('Map of plugin ID to its dependencies'),
+});
+/**
+ * Multi-Version Support Configuration
+ * Allows running multiple versions of a plugin simultaneously
+ */
+exports.MultiVersionSupportSchema = zod_1.z.object({
+    /**
+     * Enable multi-version support
+     */
+    enabled: zod_1.z.boolean().default(false),
+    /**
+     * Maximum concurrent versions
+     */
+    maxConcurrentVersions: zod_1.z.number().int().min(1).default(2)
+        .describe('How many versions can run at the same time'),
+    /**
+     * Version selection strategy
+     */
+    selectionStrategy: zod_1.z.enum([
+        'latest', // Always use latest version
+        'stable', // Use latest stable version
+        'compatible', // Use version compatible with dependencies
+        'pinned', // Use pinned version
+        'canary', // Use canary/preview version
+        'custom', // Custom selection logic
+    ]).default('latest'),
+    /**
+     * Version routing rules
+     */
+    routing: zod_1.z.array(zod_1.z.object({
+        condition: zod_1.z.string().describe('Routing condition (e.g., tenant, user, feature flag)'),
+        version: zod_1.z.string().describe('Version to use when condition matches'),
+        priority: zod_1.z.number().int().default(100).describe('Rule priority'),
+    })).optional(),
+    /**
+     * Gradual rollout configuration
+     */
+    rollout: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(false),
+        strategy: zod_1.z.enum(['percentage', 'blue-green', 'canary']),
+        percentage: zod_1.z.number().min(0).max(100).optional()
+            .describe('Percentage of traffic to new version'),
+        duration: zod_1.z.number().int().optional()
+            .describe('Rollout duration in milliseconds'),
+    }).optional(),
+});
+/**
+ * Plugin Version Metadata
+ * Complete version information for a plugin
+ */
+exports.PluginVersionMetadataSchema = zod_1.z.object({
+    /**
+     * Plugin identifier
+     */
+    pluginId: zod_1.z.string(),
+    /**
+     * Version number
+     */
+    version: exports.SemanticVersionSchema,
+    /**
+     * Version string (computed)
+     */
+    versionString: zod_1.z.string().describe('Full version string (e.g., 1.2.3-beta.1+build.123)'),
+    /**
+     * Release date
+     */
+    releaseDate: zod_1.z.string().datetime(),
+    /**
+     * Release notes
+     */
+    releaseNotes: zod_1.z.string().optional(),
+    /**
+     * Breaking changes
+     */
+    breakingChanges: zod_1.z.array(exports.BreakingChangeSchema).optional(),
+    /**
+     * Deprecations
+     */
+    deprecations: zod_1.z.array(exports.DeprecationNoticeSchema).optional(),
+    /**
+     * Compatibility matrix
+     */
+    compatibilityMatrix: zod_1.z.array(exports.CompatibilityMatrixEntrySchema).optional(),
+    /**
+     * Security vulnerabilities fixed
+     */
+    securityFixes: zod_1.z.array(zod_1.z.object({
+        cve: zod_1.z.string().optional().describe('CVE identifier'),
+        severity: zod_1.z.enum(['critical', 'high', 'medium', 'low']),
+        description: zod_1.z.string(),
+        fixedIn: zod_1.z.string().describe('Version where vulnerability was fixed'),
+    })).optional(),
+    /**
+     * Download statistics
+     */
+    statistics: zod_1.z.object({
+        downloads: zod_1.z.number().int().min(0).optional(),
+        installations: zod_1.z.number().int().min(0).optional(),
+        ratings: zod_1.z.number().min(0).max(5).optional(),
+    }).optional(),
+    /**
+     * Support status
+     */
+    support: zod_1.z.object({
+        status: zod_1.z.enum(['active', 'maintenance', 'deprecated', 'eol']),
+        endOfLife: zod_1.z.string().datetime().optional(),
+        securitySupport: zod_1.z.boolean().default(true),
+    }),
+});

package/json-schema/ai/AICodeReviewResult.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/AICodeReviewResult",
+  "definitions": {
+    "AICodeReviewResult": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/AIOpsAgentConfig.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/AIOpsAgentConfig",
+  "definitions": {
+    "AIOpsAgentConfig": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/AnomalyDetectionConfig.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/AnomalyDetectionConfig",
+  "definitions": {
+    "AnomalyDetectionConfig": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/AutoScalingPolicy.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/AutoScalingPolicy",
+  "definitions": {
+    "AutoScalingPolicy": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/CodeGenerationRequest.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/CodeGenerationRequest",
+  "definitions": {
+    "CodeGenerationRequest": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/GeneratedCode.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/GeneratedCode",
+  "definitions": {
+    "GeneratedCode": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PerformanceOptimization.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PerformanceOptimization",
+  "definitions": {
+    "PerformanceOptimization": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PluginCompositionRequest.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginCompositionRequest",
+  "definitions": {
+    "PluginCompositionRequest": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PluginCompositionResult.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginCompositionResult",
+  "definitions": {
+    "PluginCompositionResult": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PluginRecommendation.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginRecommendation",
+  "definitions": {
+    "PluginRecommendation": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PluginRecommendationRequest.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginRecommendationRequest",
+  "definitions": {
+    "PluginRecommendationRequest": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/PluginScaffoldingTemplate.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginScaffoldingTemplate",
+  "definitions": {
+    "PluginScaffoldingTemplate": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/RootCauseAnalysisRequest.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/RootCauseAnalysisRequest",
+  "definitions": {
+    "RootCauseAnalysisRequest": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/RootCauseAnalysisResult.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/RootCauseAnalysisResult",
+  "definitions": {
+    "RootCauseAnalysisResult": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/SelfHealingAction.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/SelfHealingAction",
+  "definitions": {
+    "SelfHealingAction": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/ai/SelfHealingConfig.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/SelfHealingConfig",
+  "definitions": {
+    "SelfHealingConfig": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/MarketplaceQualityMetrics.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/MarketplaceQualityMetrics",
+  "definitions": {
+    "MarketplaceQualityMetrics": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginCategory.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginCategory",
+  "definitions": {
+    "PluginCategory": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginCertification.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginCertification",
+  "definitions": {
+    "PluginCertification": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginInstallationRequest.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginInstallationRequest",
+  "definitions": {
+    "PluginInstallationRequest": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginInstallationStatus.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginInstallationStatus",
+  "definitions": {
+    "PluginInstallationStatus": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginLicense.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginLicense",
+  "definitions": {
+    "PluginLicense": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginMarketplaceListing.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginMarketplaceListing",
+  "definitions": {
+    "PluginMarketplaceListing": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginRating.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginRating",
+  "definitions": {
+    "PluginRating": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginRevenueSharing.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginRevenueSharing",
+  "definitions": {
+    "PluginRevenueSharing": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginSearchQuery.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginSearchQuery",
+  "definitions": {
+    "PluginSearchQuery": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/PluginTag.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/PluginTag",
+  "definitions": {
+    "PluginTag": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/RegistryConfig.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/RegistryConfig",
+  "definitions": {
+    "RegistryConfig": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/RegistrySyncPolicy.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/RegistrySyncPolicy",
+  "definitions": {
+    "RegistrySyncPolicy": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/hub/RegistryUpstream.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/RegistryUpstream",
+  "definitions": {
+    "RegistryUpstream": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/json-schema/system/AdvancedPluginLifecycleConfig.json

@@ -0,0 +1,7 @@
+{
+  "$ref": "#/definitions/AdvancedPluginLifecycleConfig",
+  "definitions": {
+    "AdvancedPluginLifecycleConfig": {}
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}