@originals/sdk 1.4.2 → 1.4.3

package/src/kinds/validators/AppValidator.ts

@@ -1,211 +0,0 @@
-/**
- * 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

@@ -1,242 +0,0 @@
-/**
- * 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);
-  }
-}
-