@originals/sdk 1.8.1 → 1.8.2

package/src/kinds/validators/AppValidator.ts

@@ -0,0 +1,211 @@
+/**
+ * App Kind Validator
+ * 
+ * Validates manifests for executable applications with runtime and entrypoint.
+ */
+
+import { OriginalKind, type OriginalManifest, type ValidationResult, type AppMetadata } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+
+/**
+ * Valid runtime environments
+ */
+const VALID_RUNTIMES = [
+  'node', 'deno', 'bun', 'browser', 'electron',
+  'react-native', 'python', 'ruby', 'go', 'rust',
+  'java', 'dotnet', 'wasm',
+];
+
+/**
+ * Valid platforms
+ */
+const VALID_PLATFORMS = ['linux', 'darwin', 'windows', 'web'];
+
+/**
+ * Validator for App Originals
+ */
+export class AppValidator extends BaseKindValidator<OriginalKind.App> {
+  readonly kind = OriginalKind.App;
+  
+  protected validateKind(manifest: OriginalManifest<OriginalKind.App>): ValidationResult {
+    const errors: ValidationResult['errors'] = [];
+    const warnings: ValidationResult['warnings'] = [];
+    const metadata = manifest.metadata as AppMetadata;
+    
+    // Validate metadata exists
+    if (!metadata || typeof metadata !== 'object') {
+      return ValidationUtils.failure([
+        ValidationUtils.error('MISSING_METADATA', 'App manifest must have metadata', 'metadata'),
+      ]);
+    }
+    
+    // Validate runtime (required)
+    if (!metadata.runtime || typeof metadata.runtime !== 'string') {
+      errors.push(ValidationUtils.error(
+        'MISSING_RUNTIME',
+        'App must specify a runtime environment',
+        'metadata.runtime',
+      ));
+    } else if (!VALID_RUNTIMES.includes(metadata.runtime.toLowerCase())) {
+      warnings.push(ValidationUtils.warning(
+        'UNKNOWN_RUNTIME',
+        `Runtime "${metadata.runtime}" is not a commonly recognized runtime`,
+        'metadata.runtime',
+        `Consider using one of: ${VALID_RUNTIMES.join(', ')}`,
+      ));
+    }
+    
+    // Validate entrypoint (required)
+    if (!metadata.entrypoint || typeof metadata.entrypoint !== 'string') {
+      errors.push(ValidationUtils.error(
+        'MISSING_ENTRYPOINT',
+        'App must specify an entrypoint',
+        'metadata.entrypoint',
+      ));
+    } else {
+      // Check if entrypoint references an existing resource
+      if (!ValidationUtils.resourceExists(metadata.entrypoint, manifest.resources)) {
+        // It might be a path within a resource, so just warn
+        warnings.push(ValidationUtils.warning(
+          'ENTRYPOINT_NOT_RESOURCE',
+          `Entrypoint "${metadata.entrypoint}" does not match a resource ID`,
+          'metadata.entrypoint',
+          'Ensure the entrypoint is a valid resource ID or path within a resource',
+        ));
+      }
+    }
+    
+    // Validate platforms if specified
+    if (metadata.platforms) {
+      if (!Array.isArray(metadata.platforms)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_PLATFORMS',
+          'Platforms must be an array',
+          'metadata.platforms',
+        ));
+      } else {
+        for (const platform of metadata.platforms) {
+          if (!VALID_PLATFORMS.includes(platform)) {
+            errors.push(ValidationUtils.error(
+              'INVALID_PLATFORM',
+              `Invalid platform: "${platform}"`,
+              'metadata.platforms',
+              platform,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Validate permissions if specified
+    if (metadata.permissions) {
+      if (!Array.isArray(metadata.permissions)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_PERMISSIONS',
+          'Permissions must be an array of strings',
+          'metadata.permissions',
+        ));
+      } else {
+        for (let i = 0; i < metadata.permissions.length; i++) {
+          if (typeof metadata.permissions[i] !== 'string') {
+            errors.push(ValidationUtils.error(
+              'INVALID_PERMISSION',
+              `Permission at index ${i} must be a string`,
+              `metadata.permissions[${i}]`,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Validate env if specified
+    if (metadata.env) {
+      if (typeof metadata.env !== 'object' || Array.isArray(metadata.env)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_ENV',
+          'Env must be an object',
+          'metadata.env',
+        ));
+      } else {
+        for (const [key, value] of Object.entries(metadata.env)) {
+          if (!/^[A-Z][A-Z0-9_]*$/.test(key)) {
+            warnings.push(ValidationUtils.warning(
+              'ENV_VAR_NAMING',
+              `Environment variable "${key}" should use SCREAMING_SNAKE_CASE`,
+              `metadata.env.${key}`,
+            ));
+          }
+          if (typeof value !== 'object' || value === null) {
+            errors.push(ValidationUtils.error(
+              'INVALID_ENV_VALUE',
+              `Env variable "${key}" must have an object value`,
+              `metadata.env.${key}`,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Validate icons if specified
+    if (metadata.icons) {
+      if (typeof metadata.icons !== 'object' || Array.isArray(metadata.icons)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_ICONS',
+          'Icons must be an object mapping sizes to resource IDs',
+          'metadata.icons',
+        ));
+      } else {
+        for (const [size, resourceId] of Object.entries(metadata.icons)) {
+          if (!/^\d+x\d+$/.test(size) && !/^\d+$/.test(size)) {
+            warnings.push(ValidationUtils.warning(
+              'ICON_SIZE_FORMAT',
+              `Icon size "${size}" should be in format "WxH" or just "N"`,
+              `metadata.icons.${size}`,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Validate commands if specified
+    if (metadata.commands) {
+      if (typeof metadata.commands !== 'object' || Array.isArray(metadata.commands)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_COMMANDS',
+          'Commands must be an object',
+          'metadata.commands',
+        ));
+      } else {
+        for (const [name, cmd] of Object.entries(metadata.commands)) {
+          if (!cmd || typeof cmd !== 'object') {
+            errors.push(ValidationUtils.error(
+              'INVALID_COMMAND',
+              `Command "${name}" must be an object`,
+              `metadata.commands.${name}`,
+            ));
+          } else if (!cmd.description || typeof cmd.description !== 'string') {
+            warnings.push(ValidationUtils.warning(
+              'MISSING_COMMAND_DESC',
+              `Command "${name}" should have a description`,
+              `metadata.commands.${name}.description`,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Suggest adding runtime version
+    if (!metadata.runtimeVersion && !metadata.minRuntimeVersion) {
+      warnings.push(ValidationUtils.warning(
+        'MISSING_RUNTIME_VERSION',
+        'Consider specifying runtimeVersion or minRuntimeVersion for compatibility',
+        'metadata.runtimeVersion',
+      ));
+    }
+    
+    return errors.length > 0
+      ? ValidationUtils.failure(errors, warnings)
+      : ValidationUtils.success(warnings);
+  }
+}
+

package/src/kinds/validators/DatasetValidator.ts

@@ -0,0 +1,242 @@
+/**
+ * Dataset Kind Validator
+ * 
+ * Validates manifests for structured data collections with schema definitions.
+ */
+
+import { OriginalKind, type OriginalManifest, type ValidationResult, type DatasetMetadata } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+
+/**
+ * Common data formats
+ */
+const KNOWN_FORMATS = [
+  'csv', 'json', 'jsonl', 'ndjson', 'parquet', 'avro', 'orc',
+  'xml', 'yaml', 'toml', 'tsv', 'excel', 'sqlite', 'arrow',
+];
+
+/**
+ * Valid privacy classifications
+ */
+const VALID_PRIVACY = ['public', 'internal', 'confidential', 'restricted'];
+
+/**
+ * Valid update frequencies
+ */
+const VALID_UPDATE_FREQUENCIES = ['realtime', 'hourly', 'daily', 'weekly', 'monthly', 'static'];
+
+/**
+ * Validator for Dataset Originals
+ */
+export class DatasetValidator extends BaseKindValidator<OriginalKind.Dataset> {
+  readonly kind = OriginalKind.Dataset;
+  
+  protected validateKind(manifest: OriginalManifest<OriginalKind.Dataset>): ValidationResult {
+    const errors: ValidationResult['errors'] = [];
+    const warnings: ValidationResult['warnings'] = [];
+    const metadata = manifest.metadata as DatasetMetadata;
+    
+    // Validate metadata exists
+    if (!metadata || typeof metadata !== 'object') {
+      return ValidationUtils.failure([
+        ValidationUtils.error('MISSING_METADATA', 'Dataset manifest must have metadata', 'metadata'),
+      ]);
+    }
+    
+    // Validate schema (required)
+    if (!metadata.schema) {
+      errors.push(ValidationUtils.error(
+        'MISSING_SCHEMA',
+        'Dataset must have a schema definition',
+        'metadata.schema',
+      ));
+    } else if (typeof metadata.schema !== 'object' && typeof metadata.schema !== 'string') {
+      errors.push(ValidationUtils.error(
+        'INVALID_SCHEMA',
+        'Schema must be an object (JSON Schema) or string (URL)',
+        'metadata.schema',
+      ));
+    } else if (typeof metadata.schema === 'string') {
+      // If it's a URL, validate it
+      if (!ValidationUtils.isValidURL(metadata.schema)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_SCHEMA_URL',
+          'Schema URL is not a valid URL',
+          'metadata.schema',
+          metadata.schema,
+        ));
+      }
+    }
+    
+    // Validate format (required)
+    if (!metadata.format || typeof metadata.format !== 'string') {
+      errors.push(ValidationUtils.error(
+        'MISSING_FORMAT',
+        'Dataset must specify a data format',
+        'metadata.format',
+      ));
+    } else {
+      const normalizedFormat = metadata.format.toLowerCase();
+      if (!KNOWN_FORMATS.includes(normalizedFormat)) {
+        warnings.push(ValidationUtils.warning(
+          'UNKNOWN_FORMAT',
+          `Data format "${metadata.format}" is not a commonly recognized format`,
+          'metadata.format',
+          `Consider using one of: ${KNOWN_FORMATS.join(', ')}`,
+        ));
+      }
+    }
+    
+    // Validate recordCount if specified
+    if (metadata.recordCount !== undefined) {
+      if (typeof metadata.recordCount !== 'number' || metadata.recordCount < 0 || !Number.isInteger(metadata.recordCount)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_RECORD_COUNT',
+          'Record count must be a non-negative integer',
+          'metadata.recordCount',
+          metadata.recordCount,
+        ));
+      }
+    } else {
+      warnings.push(ValidationUtils.warning(
+        'MISSING_RECORD_COUNT',
+        'Consider specifying recordCount for better discoverability',
+        'metadata.recordCount',
+      ));
+    }
+    
+    // Validate columns if specified
+    if (metadata.columns) {
+      if (!Array.isArray(metadata.columns)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_COLUMNS',
+          'Columns must be an array',
+          'metadata.columns',
+        ));
+      } else {
+        const columnNames = new Set<string>();
+        
+        for (let i = 0; i < metadata.columns.length; i++) {
+          const column = metadata.columns[i];
+          const columnPath = `metadata.columns[${i}]`;
+          
+          if (!column || typeof column !== 'object') {
+            errors.push(ValidationUtils.error(
+              'INVALID_COLUMN',
+              `Column at index ${i} must be an object`,
+              columnPath,
+            ));
+            continue;
+          }
+          
+          if (!column.name || typeof column.name !== 'string') {
+            errors.push(ValidationUtils.error(
+              'MISSING_COLUMN_NAME',
+              `Column at index ${i} must have a name`,
+              `${columnPath}.name`,
+            ));
+          } else {
+            if (columnNames.has(column.name)) {
+              errors.push(ValidationUtils.error(
+                'DUPLICATE_COLUMN',
+                `Duplicate column name: "${column.name}"`,
+                `${columnPath}.name`,
+              ));
+            }
+            columnNames.add(column.name);
+          }
+          
+          if (!column.type || typeof column.type !== 'string') {
+            errors.push(ValidationUtils.error(
+              'MISSING_COLUMN_TYPE',
+              `Column "${column.name || i}" must have a type`,
+              `${columnPath}.type`,
+            ));
+          }
+        }
+      }
+    }
+    
+    // Validate source if specified
+    if (metadata.source) {
+      if (typeof metadata.source !== 'object') {
+        errors.push(ValidationUtils.error(
+          'INVALID_SOURCE',
+          'Source must be an object',
+          'metadata.source',
+        ));
+      }
+    }
+    
+    // Validate statistics if specified
+    if (metadata.statistics) {
+      if (typeof metadata.statistics !== 'object') {
+        errors.push(ValidationUtils.error(
+          'INVALID_STATISTICS',
+          'Statistics must be an object',
+          'metadata.statistics',
+        ));
+      } else {
+        if (metadata.statistics.sizeBytes !== undefined &&
+            (typeof metadata.statistics.sizeBytes !== 'number' || metadata.statistics.sizeBytes < 0)) {
+          errors.push(ValidationUtils.error(
+            'INVALID_SIZE_BYTES',
+            'sizeBytes must be a non-negative number',
+            'metadata.statistics.sizeBytes',
+          ));
+        }
+      }
+    }
+    
+    // Validate privacy if specified
+    if (metadata.privacy) {
+      if (!VALID_PRIVACY.includes(metadata.privacy)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_PRIVACY',
+          `Privacy must be one of: ${VALID_PRIVACY.join(', ')}`,
+          'metadata.privacy',
+          metadata.privacy,
+        ));
+      }
+    } else {
+      warnings.push(ValidationUtils.warning(
+        'MISSING_PRIVACY',
+        'Consider specifying a privacy classification for the dataset',
+        'metadata.privacy',
+      ));
+    }
+    
+    // Validate updateFrequency if specified
+    if (metadata.updateFrequency) {
+      if (!VALID_UPDATE_FREQUENCIES.includes(metadata.updateFrequency)) {
+        errors.push(ValidationUtils.error(
+          'INVALID_UPDATE_FREQUENCY',
+          `Update frequency must be one of: ${VALID_UPDATE_FREQUENCIES.join(', ')}`,
+          'metadata.updateFrequency',
+          metadata.updateFrequency,
+        ));
+      }
+    }
+    
+    // Check that at least one data resource exists
+    const dataResources = manifest.resources.filter(r => 
+      r.type === 'data' ||
+      r.contentType.includes('csv') ||
+      r.contentType.includes('json') ||
+      r.contentType.includes('parquet') ||
+      r.contentType.includes('octet-stream')
+    );
+    if (dataResources.length === 0) {
+      warnings.push(ValidationUtils.warning(
+        'NO_DATA_RESOURCES',
+        'No data resources found. Ensure resources have appropriate types',
+        'resources',
+      ));
+    }
+    
+    return errors.length > 0
+      ? ValidationUtils.failure(errors, warnings)
+      : ValidationUtils.success(warnings);
+  }
+}
+