AI-Optimized Enterprise Development

{
  "metadata": {
    "package": "com.example",
    "children": [
      {
        "object": {
          "name": "Product",
          "type": "pojo",
          "children": [
            {"field": {"name": "id", "type": "long"}},
            {"field": {"name": "name", "type": "string"}},
            {"field": {"name": "price", "type": "double"}},
            {"field": {"name": "inStock", "type": "boolean"}}
          ]
        }
      }
    ]
  }
}

package com.example;

import org.draagon.metaobjects.*;
import javax.validation.constraints.*;

public class Product implements MetaDataAware {
    private final MetaObject metaObject;
    private Long id;
    private String name;
    private Double price;
    private Boolean inStock;
    
    // Constructor requires MetaObject
    public Product(MetaObject metaObject) {
        this.metaObject = metaObject;
    }
    
    // Static MetaObject reference (loaded once)
    private static MetaObject PRODUCT_META;
    
    // Factory method
    public static Product newInstance() {
        if (PRODUCT_META == null) {
            // Initialize once - in real apps this comes from DI/Spring context
            PRODUCT_META = MetaDataRegistry.getInstance().getMetaObject("Product");
        }
        return (Product) PRODUCT_META.newInstance();
    }
    
    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
    
    public Boolean getInStock() { return inStock; }
    public void setInStock(Boolean inStock) { this.inStock = inStock; }
    
    public MetaObject getMetaObject() { return metaObject; }
}

// Usage with factory method
Product product = Product.newInstance();
product.setName("Widget");
product.setPrice(29.99);

// Access MetaObject through MetaDataAware interface
MetaDataAware aware = (MetaDataAware) product;
MetaObject meta = aware.getMetaObject();
System.out.println("Object type: " + meta.getName());

import { MetaObject, MetaDataLoader, MetaDataAware } from '@draagon/metaobjects';

export interface Product {
  id: number;
  name: string;
  price: number;
  inStock: boolean;
}

export class ProductImpl implements Product, MetaDataAware {
  private readonly metaObject: MetaObject;
  id: number;
  name: string;
  price: number;
  inStock: boolean;
  
  constructor(metaObject: MetaObject) {
    this.metaObject = metaObject;
  }
  
  // Static MetaObject reference (loaded once)
  private static productMeta: MetaObject;
  
  // Factory method
  static newInstance(): ProductImpl {
    if (!ProductImpl.productMeta) {
      // Initialize once - in real apps this comes from DI context
      ProductImpl.productMeta = MetaDataRegistry.getInstance().getMetaObject('Product');
    }
    return ProductImpl.productMeta.newInstance() as ProductImpl;
  }
  
  setName(name: string): void { this.name = name; }
  setPrice(price: number): void { this.price = price; }
  
  getMetaObject(): MetaObject { return this.metaObject; }
}

export const ProductValidator = {
  validate(product: Product): ValidationResult {
    // Auto-generated validation logic
  }
};

// Usage with factory method
const product = ProductImpl.newInstance();
product.setName("Widget");
product.setPrice(29.99);

// Access MetaObject through MetaDataAware interface
const aware: MetaDataAware = product;
const meta = aware.getMetaObject();
console.log(`Object type: ${meta.getName()}`);

using System.ComponentModel.DataAnnotations;
using MetaObjects;

namespace Com.Example
{
    public class Product : IMetaDataAware
    {
        private readonly MetaObject metaObject;
        
        public long? Id { get; set; }
        public string Name { get; set; }
        public double? Price { get; set; }
        public bool? InStock { get; set; }
        
        // Constructor requires MetaObject
        public Product(MetaObject metaObject) 
        {
            this.metaObject = metaObject;
        }
        
        // Static MetaObject reference (loaded once)
        private static MetaObject ProductMeta;
        
        // Factory method
        public static Product NewInstance() 
        {
            if (ProductMeta == null) 
            {
                // Initialize once - in real apps this comes from DI container
                ProductMeta = MetaDataRegistry.Instance.GetMetaObject("Product");
            }
            return (Product)ProductMeta.NewInstance();
        }
        
        // Fluent setters
        public Product SetName(string name) 
        { 
            Name = name; 
            return this; 
        }
        
        public Product SetPrice(double price) 
        { 
            Price = price; 
            return this; 
        }
        
        public MetaObject GetMetaObject() { return metaObject; }
    }
}

// Usage with factory method
var product = Product.NewInstance()
    .SetName("Widget")
    .SetPrice(29.99);

// Access MetaObject through IMetaDataAware interface
IMetaDataAware aware = product;
MetaObject meta = aware.GetMetaObject();
Console.WriteLine($"Object type: {meta.GetName()}");

// Load metadata with proper configuration
FileMetaDataLoader loader = new FileMetaDataLoader(
    new FileLoaderOptions()
        .addParser("*.json", JsonMetaDataParser.class)
        .addSources(new LocalFileMetaDataSources(
            Arrays.asList(
                "com/draagon/meta/loader/xml/metaobjects.types.json",
                "metadata/ecommerce/product.metadata.json"
            )
        )),
    "ecommerce-example"
).init();

MetaObject productMeta = loader.getMetaObject("Product");

// Create instance without generated classes
Object product = productMeta.newInstance();
productMeta.setFieldValue(product, "name", "Widget");
productMeta.setFieldValue(product, "price", 29.99);
productMeta.setFieldValue(product, "inStock", true);

// Validate using metadata
ValidationResult result = productMeta.performValidation(product);

// Access any field dynamically
String name = (String) productMeta.getFieldValue(product, "name");
Double price = (Double) productMeta.getFieldValue(product, "price");

// product.overlay.json - Add new fields without code changes
{
  "metadata": {
    "package": "com.example",
    "children": [{
      "object": {
        "name": "Product",
        "overlay": true,
        "children": [
          {"field": {"name": "description", "type": "string"}}
        ]
      }
    }]
  }
}

// Load base metadata + overlay with proper configuration
FileMetaDataLoader loader = new FileMetaDataLoader(
    new FileLoaderOptions()
        .addParser("*.json", JsonMetaDataParser.class)
        .addSources(new LocalFileMetaDataSources(
            Arrays.asList(
                "com/draagon/meta/loader/xml/metaobjects.types.json",
                "metadata/ecommerce/product.metadata.json",
                "metadata/ecommerce/product.overlay.json"
            )
        )),
    "ecommerce-with-overlay"
).init();

MetaObject productMeta = loader.getMetaObject("Product");

// Create Product using MetaObject and cast to generated class
Product product = (Product) productMeta.newInstance();

// Use generated setters for standard fields
product.setName("Advanced Widget");
product.setPrice(49.99);

// Use metadata manipulation for dynamic overlay fields
productMeta.setFieldValue(product, "description", 
    "High-quality widget with advanced features");

// Access the new field through metadata
String desc = (String) productMeta.getFieldValue(product, "description");
System.out.println("Description: " + desc);

// Validate with new field constraints
ValidationResult result = productMeta.performValidation(product);

// Generic method that works with any MetaDataAware object
public void processMetaDataAware(MetaDataAware obj) {
    MetaObject meta = obj.getMetaObject();
    System.out.println("Processing object of type: " + meta.getName());
    
    // Access fields generically
    for (MetaField field : meta.getMetaFields()) {
        Object value = meta.getFieldValue(obj, field.getName());
        System.out.println("  " + field.getName() + " = " + value);
    }
    
    // Perform validation
    ValidationResult result = meta.performValidation(obj);
    if (!result.isValid()) {
        System.out.println("  Validation errors: " + result.getErrors());
    }
}

// Usage with multiple different objects
Product product = Product.newInstance();
User user = User.newInstance();  // Another generated class
Order order = Order.newInstance(); // Yet another generated class

// All can be processed generically through MetaDataAware
processMetaDataAware(product);
processMetaDataAware(user);
processMetaDataAware(order);

// Or in collections
List<MetaDataAware> objects = Arrays.asList(product, user, order);
objects.forEach(this::processMetaDataAware);