@objectstack/metadata 0.7.1

package/src/serializers/json-serializer.ts

@@ -0,0 +1,71 @@
+/**
+ * JSON Metadata Serializer
+ * 
+ * Handles JSON format serialization and deserialization
+ */
+
+import type { z } from 'zod';
+import type { MetadataFormat } from '@objectstack/spec/system';
+import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
+
+export class JSONSerializer implements MetadataSerializer {
+  serialize<T>(item: T, options?: SerializeOptions): string {
+    const { prettify = true, indent = 2, sortKeys = false } = options || {};
+
+    if (sortKeys) {
+      // Sort keys recursively
+      const sorted = this.sortObjectKeys(item);
+      return prettify
+        ? JSON.stringify(sorted, null, indent)
+        : JSON.stringify(sorted);
+    }
+
+    return prettify
+      ? JSON.stringify(item, null, indent)
+      : JSON.stringify(item);
+  }
+
+  deserialize<T>(content: string, schema?: z.ZodSchema): T {
+    const parsed = JSON.parse(content);
+
+    if (schema) {
+      return schema.parse(parsed) as T;
+    }
+
+    return parsed as T;
+  }
+
+  getExtension(): string {
+    return '.json';
+  }
+
+  canHandle(format: MetadataFormat): boolean {
+    return format === 'json';
+  }
+
+  getFormat(): MetadataFormat {
+    return 'json';
+  }
+
+  /**
+   * Recursively sort object keys
+   */
+  private sortObjectKeys(obj: any): any {
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.sortObjectKeys(item));
+    }
+
+    const sorted: Record<string, any> = {};
+    const keys = Object.keys(obj).sort();
+
+    for (const key of keys) {
+      sorted[key] = this.sortObjectKeys(obj[key]);
+    }
+
+    return sorted;
+  }
+}

package/src/serializers/serializer-interface.ts

@@ -0,0 +1,63 @@
+/**
+ * Metadata Serializer Interface
+ * 
+ * Defines the contract for serializing/deserializing metadata
+ */
+
+import type { z } from 'zod';
+import type { MetadataFormat } from '@objectstack/spec/system';
+
+/**
+ * Serialization options
+ */
+export interface SerializeOptions {
+  /** Prettify output (formatted with indentation) */
+  prettify?: boolean;
+  /** Indentation size (spaces) */
+  indent?: number;
+  /** Sort object keys alphabetically */
+  sortKeys?: boolean;
+  /** Include default values in output */
+  includeDefaults?: boolean;
+}
+
+/**
+ * Abstract interface for metadata serializers
+ * Implementations handle different formats (JSON, YAML, TypeScript, etc.)
+ */
+export interface MetadataSerializer {
+  /**
+   * Serialize object to string
+   * @param item The item to serialize
+   * @param options Serialization options
+   * @returns Serialized string
+   */
+  serialize<T>(item: T, options?: SerializeOptions): string;
+
+  /**
+   * Deserialize string to object
+   * @param content The content to deserialize
+   * @param schema Optional Zod schema for validation
+   * @returns Deserialized object
+   */
+  deserialize<T>(content: string, schema?: z.ZodSchema): T;
+
+  /**
+   * Get file extension for this format
+   * @returns File extension (e.g., '.json', '.yaml')
+   */
+  getExtension(): string;
+
+  /**
+   * Check if this serializer can handle the format
+   * @param format The format to check
+   * @returns True if can handle
+   */
+  canHandle(format: MetadataFormat): boolean;
+
+  /**
+   * Get the format this serializer handles
+   * @returns The metadata format
+   */
+  getFormat(): MetadataFormat;
+}

package/src/serializers/serializers.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { JSONSerializer } from '../serializers/json-serializer';
+import { YAMLSerializer } from '../serializers/yaml-serializer';
+import { TypeScriptSerializer } from '../serializers/typescript-serializer';
+
+describe('Serializers', () => {
+  describe('JSONSerializer', () => {
+    const serializer = new JSONSerializer();
+
+    it('should serialize to JSON', () => {
+      const data = { name: 'test', value: 42 };
+      const result = serializer.serialize(data);
+      expect(result).toContain('"name"');
+      expect(result).toContain('"test"');
+    });
+
+    it('should deserialize from JSON', () => {
+      const json = '{"name":"test","value":42}';
+      const result = serializer.deserialize(json);
+      expect(result).toEqual({ name: 'test', value: 42 });
+    });
+
+    it('should prettify JSON', () => {
+      const data = { name: 'test' };
+      const result = serializer.serialize(data, { prettify: true, indent: 2 });
+      expect(result).toContain('\n');
+      expect(result).toContain('  ');
+    });
+
+    it('should sort keys', () => {
+      const data = { zebra: 1, apple: 2, banana: 3 };
+      const result = serializer.serialize(data, { sortKeys: true });
+      const keys = Object.keys(JSON.parse(result));
+      expect(keys).toEqual(['apple', 'banana', 'zebra']);
+    });
+  });
+
+  describe('YAMLSerializer', () => {
+    const serializer = new YAMLSerializer();
+
+    it('should serialize to YAML', () => {
+      const data = { name: 'test', value: 42 };
+      const result = serializer.serialize(data);
+      expect(result).toContain('name: test');
+      expect(result).toContain('value: 42');
+    });
+
+    it('should deserialize from YAML', () => {
+      const yaml = 'name: test\nvalue: 42';
+      const result = serializer.deserialize(yaml);
+      expect(result).toEqual({ name: 'test', value: 42 });
+    });
+  });
+
+  describe('TypeScriptSerializer', () => {
+    const serializer = new TypeScriptSerializer('typescript');
+
+    it('should serialize to TypeScript module', () => {
+      const data = { name: 'test', value: 42 };
+      const result = serializer.serialize(data);
+      expect(result).toContain('import type');
+      expect(result).toContain('export const metadata');
+      expect(result).toContain('export default metadata');
+    });
+
+    it('should get correct extension', () => {
+      const ts = new TypeScriptSerializer('typescript');
+      expect(ts.getExtension()).toBe('.ts');
+
+      const js = new TypeScriptSerializer('javascript');
+      expect(js.getExtension()).toBe('.js');
+    });
+  });
+});

package/src/serializers/typescript-serializer.ts

@@ -0,0 +1,125 @@
+/**
+ * TypeScript/JavaScript Metadata Serializer
+ * 
+ * Handles TypeScript/JavaScript module format serialization and deserialization
+ */
+
+import type { z } from 'zod';
+import type { MetadataFormat } from '@objectstack/spec/system';
+import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
+
+export class TypeScriptSerializer implements MetadataSerializer {
+  constructor(private format: 'typescript' | 'javascript' = 'typescript') {}
+
+  serialize<T>(item: T, options?: SerializeOptions): string {
+    const { prettify = true, indent = 2 } = options || {};
+
+    const jsonStr = JSON.stringify(item, null, prettify ? indent : 0);
+    
+    if (this.format === 'typescript') {
+      return `import type { ServiceObject } from '@objectstack/spec/data';\n\n` +
+        `export const metadata: ServiceObject = ${jsonStr};\n\n` +
+        `export default metadata;\n`;
+    } else {
+      return `export const metadata = ${jsonStr};\n\n` +
+        `export default metadata;\n`;
+    }
+  }
+
+  deserialize<T>(content: string, schema?: z.ZodSchema): T {
+    // For TypeScript/JavaScript files, we need to extract the exported object
+    // Note: This is a simplified parser that works with JSON-like object literals
+    // For complex TypeScript with nested objects, consider using a proper TypeScript parser
+    
+    // Try to find the object literal in various export patterns
+    // Pattern 1: export const metadata = {...};
+    let objectStart = content.indexOf('export const');
+    if (objectStart === -1) {
+      // Pattern 2: export default {...};
+      objectStart = content.indexOf('export default');
+    }
+    
+    if (objectStart === -1) {
+      throw new Error(
+        'Could not parse TypeScript/JavaScript module. ' +
+        'Expected export pattern: "export const metadata = {...};" or "export default {...};"'
+      );
+    }
+
+    // Find the first opening brace after the export statement
+    const braceStart = content.indexOf('{', objectStart);
+    if (braceStart === -1) {
+      throw new Error('Could not find object literal in export statement');
+    }
+
+    // Find the matching closing brace by counting braces
+    // Handle string literals to avoid counting braces inside strings
+    let braceCount = 0;
+    let braceEnd = -1;
+    let inString = false;
+    let stringChar = '';
+    
+    for (let i = braceStart; i < content.length; i++) {
+      const char = content[i];
+      const prevChar = i > 0 ? content[i - 1] : '';
+      
+      // Track string literals (simple handling of " and ')
+      if ((char === '"' || char === "'") && prevChar !== '\\') {
+        if (!inString) {
+          inString = true;
+          stringChar = char;
+        } else if (char === stringChar) {
+          inString = false;
+          stringChar = '';
+        }
+      }
+      
+      // Count braces only when not inside strings
+      if (!inString) {
+        if (char === '{') braceCount++;
+        if (char === '}') {
+          braceCount--;
+          if (braceCount === 0) {
+            braceEnd = i;
+            break;
+          }
+        }
+      }
+    }
+
+    if (braceEnd === -1) {
+      throw new Error('Could not find matching closing brace for object literal');
+    }
+
+    // Extract the object literal
+    const objectLiteral = content.substring(braceStart, braceEnd + 1);
+
+    try {
+      // Parse as JSON
+      const parsed = JSON.parse(objectLiteral);
+
+      if (schema) {
+        return schema.parse(parsed) as T;
+      }
+
+      return parsed as T;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse object literal as JSON: ${error instanceof Error ? error.message : String(error)}. ` +
+        'Make sure the TypeScript/JavaScript object uses JSON-compatible syntax (no functions, comments, or trailing commas).'
+      );
+    }
+  }
+
+  getExtension(): string {
+    return this.format === 'typescript' ? '.ts' : '.js';
+  }
+
+  canHandle(format: MetadataFormat): boolean {
+    return format === 'typescript' || format === 'javascript';
+  }
+
+  getFormat(): MetadataFormat {
+    return this.format;
+  }
+}

package/src/serializers/yaml-serializer.ts

@@ -0,0 +1,47 @@
+/**
+ * YAML Metadata Serializer
+ * 
+ * Handles YAML format serialization and deserialization
+ */
+
+import * as yaml from 'js-yaml';
+import type { z } from 'zod';
+import type { MetadataFormat } from '@objectstack/spec/system';
+import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
+
+export class YAMLSerializer implements MetadataSerializer {
+  serialize<T>(item: T, options?: SerializeOptions): string {
+    const { indent = 2, sortKeys = false } = options || {};
+
+    return yaml.dump(item, {
+      indent,
+      sortKeys,
+      lineWidth: -1, // Disable line wrapping
+      noRefs: true,  // Disable YAML references
+    });
+  }
+
+  deserialize<T>(content: string, schema?: z.ZodSchema): T {
+    // Use JSON_SCHEMA to prevent arbitrary code execution
+    // This restricts YAML to JSON-compatible types only
+    const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
+
+    if (schema) {
+      return schema.parse(parsed) as T;
+    }
+
+    return parsed as T;
+  }
+
+  getExtension(): string {
+    return '.yaml';
+  }
+
+  canHandle(format: MetadataFormat): boolean {
+    return format === 'yaml';
+  }
+
+  getFormat(): MetadataFormat {
+    return 'yaml';
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ES2020",
+    "moduleResolution": "bundler"
+  }
+}