@plures/praxis 0.2.0

package/src/core/logic/generator.ts

@@ -0,0 +1,420 @@
+/**
+ * Praxis Logic Generator
+ * 
+ * Generates logic module code from schema definitions.
+ */
+
+import type {
+  FactDefinition,
+  EventDefinition,
+  RuleDefinition,
+} from '../schema/types.js';
+import type { NormalizedSchema } from '../schema/normalize.js';
+
+/**
+ * Logic generation options
+ */
+export interface LogicGeneratorOptions {
+  /** Output directory */
+  outputDir: string;
+  /** Generate TypeScript */
+  typescript?: boolean;
+  /** Include documentation comments */
+  includeDocs?: boolean;
+}
+
+/**
+ * Generated logic file
+ */
+export interface GeneratedLogicFile {
+  /** File path */
+  path: string;
+  /** File content */
+  content: string;
+  /** File type */
+  type: 'facts' | 'events' | 'rules' | 'engine' | 'index';
+}
+
+/**
+ * Logic generator class
+ */
+export class LogicGenerator {
+  private options: LogicGeneratorOptions;
+  
+  constructor(options: LogicGeneratorOptions) {
+    this.options = {
+      typescript: true,
+      includeDocs: true,
+      ...options,
+    };
+  }
+  
+  /**
+   * Generate all logic files from schema
+   */
+  generateLogic(schema: NormalizedSchema): GeneratedLogicFile[] {
+    const files: GeneratedLogicFile[] = [];
+    
+    // Collect all logic definitions
+    const allLogic = schema.logic || [];
+    
+    if (allLogic.length === 0) {
+      // Generate minimal structure even without logic definitions
+      files.push(this.generateFactsFile([]));
+      files.push(this.generateEventsFile([]));
+      files.push(this.generateRulesFile([]));
+      files.push(this.generateEngineFile(schema));
+      files.push(this.generateIndexFile());
+      return files;
+    }
+    
+    // Collect all facts, events, and rules from logic definitions
+    const allFacts = allLogic.flatMap((logic) => logic.facts || []);
+    const allEvents = allLogic.flatMap((logic) => logic.events || []);
+    const allRules = allLogic.flatMap((logic) => logic.rules || []);
+    
+    // Generate individual files
+    files.push(this.generateFactsFile(allFacts));
+    files.push(this.generateEventsFile(allEvents));
+    files.push(this.generateRulesFile(allRules));
+    files.push(this.generateEngineFile(schema));
+    files.push(this.generateIndexFile());
+    
+    return files;
+  }
+  
+  /**
+   * Generate facts.ts file
+   */
+  private generateFactsFile(facts: FactDefinition[]): GeneratedLogicFile {
+    const ext = this.options.typescript ? 'ts' : 'js';
+    const lines: string[] = [];
+    
+    lines.push("import { defineFact } from '@plures/praxis';");
+    lines.push('');
+    
+    if (this.options.includeDocs) {
+      lines.push('/**');
+      lines.push(' * Fact definitions');
+      lines.push(' */');
+      lines.push('');
+    }
+    
+    if (facts.length === 0) {
+      lines.push('// No facts defined in schema');
+      lines.push('// Example:');
+      lines.push('// export const UserCreated = defineFact<"UserCreated", { userId: string }>("UserCreated");');
+    } else {
+      for (const fact of facts) {
+        if (this.options.includeDocs && fact.description) {
+          lines.push(`/** ${fact.description} */`);
+        }
+        
+        const payloadType = this.generatePayloadType(fact.payload);
+        lines.push(
+          `export const ${fact.tag} = defineFact<"${fact.tag}", ${payloadType}>("${fact.tag}");`
+        );
+        lines.push('');
+      }
+    }
+    
+    return {
+      path: `${this.options.outputDir}/facts.${ext}`,
+      content: lines.join('\n'),
+      type: 'facts',
+    };
+  }
+  
+  /**
+   * Generate events.ts file
+   */
+  private generateEventsFile(events: EventDefinition[]): GeneratedLogicFile {
+    const ext = this.options.typescript ? 'ts' : 'js';
+    const lines: string[] = [];
+    
+    lines.push("import { defineEvent } from '@plures/praxis';");
+    lines.push('');
+    
+    if (this.options.includeDocs) {
+      lines.push('/**');
+      lines.push(' * Event definitions');
+      lines.push(' */');
+      lines.push('');
+    }
+    
+    if (events.length === 0) {
+      lines.push('// No events defined in schema');
+      lines.push('// Example:');
+      lines.push('// export const CreateUser = defineEvent<"CREATE_USER", { name: string; email: string }>("CREATE_USER");');
+    } else {
+      for (const event of events) {
+        if (this.options.includeDocs && event.description) {
+          lines.push(`/** ${event.description} */`);
+        }
+        
+        const payloadType = this.generatePayloadType(event.payload);
+        lines.push(
+          `export const ${event.tag} = defineEvent<"${event.tag}", ${payloadType}>("${event.tag}");`
+        );
+        lines.push('');
+      }
+    }
+    
+    return {
+      path: `${this.options.outputDir}/events.${ext}`,
+      content: lines.join('\n'),
+      type: 'events',
+    };
+  }
+  
+  /**
+   * Generate rules.ts file
+   */
+  private generateRulesFile(rules: RuleDefinition[]): GeneratedLogicFile {
+    const ext = this.options.typescript ? 'ts' : 'js';
+    const lines: string[] = [];
+    
+    lines.push("import { defineRule } from '@plures/praxis';");
+    lines.push("import * as Facts from './facts.js';");
+    lines.push("import * as Events from './events.js';");
+    lines.push('');
+    
+    if (this.options.includeDocs) {
+      lines.push('/**');
+      lines.push(' * Rule definitions');
+      lines.push(' */');
+      lines.push('');
+    }
+    
+    if (rules.length === 0) {
+      lines.push('// No rules defined in schema');
+      lines.push('// Example:');
+      lines.push('// export const createUserRule = defineRule({');
+      lines.push("//   id: 'user.create',");
+      lines.push("//   description: 'Create user on CREATE_USER event',");
+      lines.push('//   impl: (state, events) => {');
+      lines.push('//     const event = events.find(Events.CreateUser.is);');
+      lines.push('//     if (event) {');
+      lines.push('//       return [Facts.UserCreated.create({ userId: "new-id" })];');
+      lines.push('//     }');
+      lines.push('//     return [];');
+      lines.push('//   },');
+      lines.push('// });');
+      lines.push('');
+      lines.push('export const rules = [];');
+    } else {
+      for (const rule of rules) {
+        if (this.options.includeDocs && rule.description) {
+          lines.push(`/** ${rule.description} */`);
+        }
+        
+        lines.push(`export const ${this.sanitizeIdentifier(rule.id)}Rule = defineRule({`);
+        lines.push(`  id: '${rule.id}',`);
+        lines.push(`  description: '${rule.description}',`);
+        
+        if (rule.priority !== undefined) {
+          lines.push(`  priority: ${rule.priority},`);
+        }
+        
+        lines.push('  impl: (state, events) => {');
+        lines.push(`    // TODO: Implement rule logic for "${rule.id}"`);
+        lines.push('    // Condition: ' + (rule.when || 'always'));
+        lines.push('    // Action: ' + rule.then);
+        lines.push('    return [];');
+        lines.push('  },');
+        lines.push('});');
+        lines.push('');
+      }
+      
+      // Export all rules as array
+      lines.push('export const rules = [');
+      for (const rule of rules) {
+        lines.push(`  ${this.sanitizeIdentifier(rule.id)}Rule,`);
+      }
+      lines.push('];');
+    }
+    
+    return {
+      path: `${this.options.outputDir}/rules.${ext}`,
+      content: lines.join('\n'),
+      type: 'rules',
+    };
+  }
+  
+  /**
+   * Generate engine.ts file
+   */
+  private generateEngineFile(schema: NormalizedSchema): GeneratedLogicFile {
+    const ext = this.options.typescript ? 'ts' : 'js';
+    const lines: string[] = [];
+    
+    lines.push("import { createPraxisEngine, PraxisRegistry } from '@plures/praxis';");
+    lines.push("import { rules } from './rules.js';");
+    lines.push('');
+    
+    if (this.options.includeDocs) {
+      lines.push('/**');
+      lines.push(` * ${schema.name} Logic Engine`);
+      if (schema.description) {
+        lines.push(` * ${schema.description}`);
+      }
+      lines.push(' */');
+      lines.push('');
+    }
+    
+    // Generate context type from models
+    if (this.options.typescript) {
+      lines.push('/**');
+      lines.push(' * Application context type');
+      lines.push(' */');
+      lines.push('export interface AppContext {');
+      
+      if (schema.models && schema.models.length > 0) {
+        for (const model of schema.models) {
+          lines.push(`  ${model.name.toLowerCase()}s: ${model.name}[];`);
+        }
+      } else {
+        lines.push('  // Add your context properties here');
+      }
+      
+      lines.push('}');
+      lines.push('');
+      
+      // Generate model types
+      if (schema.models && schema.models.length > 0) {
+        for (const model of schema.models) {
+          lines.push(`export interface ${model.name} {`);
+          for (const field of model.fields) {
+            const optional = field.optional ? '?' : '';
+            const type = this.mapFieldType(field.type);
+            lines.push(`  ${field.name}${optional}: ${type};`);
+          }
+          lines.push('}');
+          lines.push('');
+        }
+      }
+    }
+    
+    // Create registry and engine
+    lines.push('/**');
+    lines.push(' * Create the logic engine');
+    lines.push(' */');
+    lines.push('export function createEngine() {');
+    lines.push('  const registry = new PraxisRegistry<AppContext>();');
+    lines.push('');
+    lines.push('  // Register all rules');
+    lines.push('  for (const rule of rules) {');
+    lines.push('    registry.registerRule(rule);');
+    lines.push('  }');
+    lines.push('');
+    lines.push('  // Create engine with initial context');
+    lines.push('  const initialContext: AppContext = {');
+    
+    if (schema.models && schema.models.length > 0) {
+      for (const model of schema.models) {
+        lines.push(`    ${model.name.toLowerCase()}s: [],`);
+      }
+    } else {
+      lines.push('    // Initialize your context here');
+    }
+    
+    lines.push('  };');
+    lines.push('');
+    lines.push('  return createPraxisEngine({');
+    lines.push('    initialContext,');
+    lines.push('    registry,');
+    lines.push('  });');
+    lines.push('}');
+    
+    return {
+      path: `${this.options.outputDir}/engine.${ext}`,
+      content: lines.join('\n'),
+      type: 'engine',
+    };
+  }
+  
+  /**
+   * Generate index.ts file
+   */
+  private generateIndexFile(): GeneratedLogicFile {
+    const ext = this.options.typescript ? 'ts' : 'js';
+    const lines: string[] = [];
+    
+    lines.push("export * from './facts.js';");
+    lines.push("export * from './events.js';");
+    lines.push("export * from './rules.js';");
+    lines.push("export * from './engine.js';");
+    
+    return {
+      path: `${this.options.outputDir}/index.${ext}`,
+      content: lines.join('\n'),
+      type: 'index',
+    };
+  }
+  
+  /**
+   * Generate TypeScript type from payload definition
+   */
+  private generatePayloadType(payload: Record<string, string>): string {
+    const fields = Object.entries(payload)
+      .map(([key, type]) => `${key}: ${type}`)
+      .join('; ');
+    return `{ ${fields} }`;
+  }
+  
+  /**
+   * Map field type to TypeScript type
+   */
+  private mapFieldType(type: any): string {
+    if (typeof type === 'string') {
+      switch (type) {
+        case 'string':
+          return 'string';
+        case 'number':
+          return 'number';
+        case 'boolean':
+          return 'boolean';
+        case 'date':
+          return 'Date';
+        case 'array':
+          return 'unknown[]';
+        case 'object':
+          return 'Record<string, unknown>';
+        default:
+          return 'unknown';
+      }
+    }
+    
+    if (typeof type === 'object') {
+      if ('array' in type) {
+        const innerType = this.mapFieldType(type.array);
+        return `${innerType}[]`;
+      }
+      if ('reference' in type) {
+        return type.reference;
+      }
+    }
+    
+    return 'unknown';
+  }
+  
+  /**
+   * Sanitize identifier for variable names
+   */
+  private sanitizeIdentifier(id: string): string {
+    return id.replace(/[^a-zA-Z0-9_]/g, '_');
+  }
+}
+
+/**
+ * Create a logic generator
+ */
+export function createLogicGenerator(
+  outputDir: string,
+  options?: Partial<LogicGeneratorOptions>
+): LogicGenerator {
+  return new LogicGenerator({
+    outputDir,
+    ...options,
+  });
+}

package/src/core/pluresdb/generator.ts

@@ -0,0 +1,229 @@
+/**
+ * PluresDB Config Generator
+ * 
+ * Generates PluresDB configuration from schema definitions.
+ */
+
+import type { NormalizedSchema, NormalizedModel } from '../schema/normalize.js';
+
+/**
+ * PluresDB config generation options
+ */
+export interface PluresDBGeneratorOptions {
+  /** Output directory */
+  outputDir: string;
+  /** Database name */
+  dbName?: string;
+  /** Database version */
+  dbVersion?: number;
+  /** Enable sync */
+  enableSync?: boolean;
+  /** Sync endpoint */
+  syncEndpoint?: string;
+  /** Auto-index strategy: 'all' indexes all string/number/date fields, 'explicit' only indexes fields defined in schema, 'none' disables auto-indexing */
+  autoIndex?: 'all' | 'explicit' | 'none';
+}
+
+/**
+ * Generated PluresDB config file
+ */
+export interface GeneratedPluresDBFile {
+  /** File path */
+  path: string;
+  /** File content */
+  content: string;
+  /** File type */
+  type: 'config' | 'types';
+}
+
+/**
+ * PluresDB store definition
+ */
+interface StoreDefinition {
+  keyPath: string;
+  indexes: string[];
+}
+
+/**
+ * PluresDB generator class
+ */
+export class PluresDBGenerator {
+  private options: PluresDBGeneratorOptions;
+  
+  constructor(options: PluresDBGeneratorOptions) {
+    this.options = {
+      dbVersion: 1,
+      enableSync: false,
+      autoIndex: 'all', // Default to indexing all fields for backward compatibility
+      ...options,
+    };
+  }
+  
+  /**
+   * Generate PluresDB configuration from schema
+   */
+  generateConfig(schema: NormalizedSchema): GeneratedPluresDBFile[] {
+    const files: GeneratedPluresDBFile[] = [];
+    
+    // Generate the main config file
+    files.push(this.generateConfigFile(schema));
+    
+    return files;
+  }
+  
+  /**
+   * Generate pluresdb-config.ts file
+   */
+  private generateConfigFile(schema: NormalizedSchema): GeneratedPluresDBFile {
+    const lines: string[] = [];
+    const dbName = this.options.dbName || schema.name.toLowerCase();
+    
+    lines.push('/**');
+    lines.push(` * PluresDB Configuration for ${schema.name}`);
+    lines.push(' * Generated from Praxis schema');
+    lines.push(' */');
+    lines.push('');
+    
+    // Import statement (for future PluresDB integration)
+    lines.push('// import { createPluresDB } from \'@plures/pluresdb\';');
+    lines.push('');
+    
+    // Generate store definitions
+    lines.push('/**');
+    lines.push(' * Database store configuration');
+    lines.push(' * ');
+    
+    // Document indexing behavior based on configuration
+    const autoIndexStrategy = this.options.autoIndex || 'all';
+    if (autoIndexStrategy === 'all') {
+      lines.push(' * Indexing: All string, number, and date fields are auto-indexed by default.');
+      lines.push(' * For large datasets, consider using autoIndex: "explicit" to only index');
+      lines.push(' * fields explicitly defined in the schema.');
+    } else if (autoIndexStrategy === 'explicit') {
+      lines.push(' * Indexing: Only fields explicitly defined in schema indexes are indexed.');
+    } else if (autoIndexStrategy === 'none') {
+      lines.push(' * Indexing: Auto-indexing disabled. Only explicit schema indexes are used.');
+    }
+    lines.push(' */');
+    lines.push('export const stores = {');
+    
+    if (schema.models && schema.models.length > 0) {
+      for (const model of schema.models) {
+        const storeName = model.name.toLowerCase() + 's';
+        const storeConfig = this.generateStoreConfig(model);
+        
+        lines.push(`  ${storeName}: {`);
+        lines.push(`    keyPath: '${storeConfig.keyPath}',`);
+        
+        if (storeConfig.indexes.length > 0) {
+          lines.push(`    indexes: [${storeConfig.indexes.map(idx => `'${idx}'`).join(', ')}],`);
+        }
+        
+        lines.push('  },');
+      }
+    } else {
+      lines.push('  // No models defined in schema');
+    }
+    
+    lines.push('};');
+    lines.push('');
+    
+    // Generate main config
+    lines.push('/**');
+    lines.push(' * Database configuration');
+    lines.push(' */');
+    lines.push('export const dbConfig = {');
+    lines.push(`  name: '${dbName}',`);
+    lines.push(`  version: ${this.options.dbVersion},`);
+    lines.push('  stores,');
+    
+    if (this.options.enableSync) {
+      lines.push('  sync: {');
+      lines.push('    enabled: true,');
+      
+      if (this.options.syncEndpoint) {
+        lines.push(`    endpoint: '${this.options.syncEndpoint}',`);
+      } else {
+        lines.push('    endpoint: \'ws://localhost:8080/sync\',');
+      }
+      
+      lines.push('    conflictResolution: \'last-write-wins\',');
+      lines.push('  },');
+    }
+    
+    lines.push('};');
+    lines.push('');
+    
+    // Generate initialization function
+    lines.push('/**');
+    lines.push(' * Initialize PluresDB');
+    lines.push(' */');
+    lines.push('export function initDB() {');
+    lines.push('  // TODO: Implement PluresDB initialization');
+    lines.push('  // return createPluresDB(dbConfig);');
+    lines.push('  console.log(\'PluresDB config ready:\', dbConfig);');
+    lines.push('  return null;');
+    lines.push('}');
+    
+    return {
+      path: `${this.options.outputDir}/pluresdb-config.ts`,
+      content: lines.join('\n'),
+      type: 'config',
+    };
+  }
+  
+  /**
+   * Generate store configuration for a model
+   */
+  private generateStoreConfig(model: NormalizedModel): StoreDefinition {
+    // Find the ID field (or use 'id' as default)
+    const idField = model.fields.find(f => f.name === 'id' || f.name === '_id');
+    const keyPath = idField ? idField.name : 'id';
+    
+    const indexes: string[] = [];
+    
+    // Apply auto-indexing based on configuration
+    const autoIndexStrategy = this.options.autoIndex || 'all';
+    
+    if (autoIndexStrategy === 'all') {
+      // Auto-index all string, number, and date fields for query performance
+      for (const field of model.fields) {
+        if (field.name !== keyPath) {
+          if (field.type === 'string' || field.type === 'number' || field.type === 'date') {
+            indexes.push(field.name);
+          }
+        }
+      }
+    }
+    // For 'explicit' and 'none', we only add indexes explicitly defined in the schema
+    
+    // Always add indexes from schema index definitions (overrides auto-indexing)
+    if (model.indexes) {
+      for (const indexDef of model.indexes) {
+        for (const fieldName of indexDef.fields) {
+          if (!indexes.includes(fieldName) && fieldName !== keyPath) {
+            indexes.push(fieldName);
+          }
+        }
+      }
+    }
+    
+    return {
+      keyPath,
+      indexes,
+    };
+  }
+}
+
+/**
+ * Create a PluresDB generator
+ */
+export function createPluresDBGenerator(
+  outputDir: string,
+  options?: Partial<PluresDBGeneratorOptions>
+): PluresDBGenerator {
+  return new PluresDBGenerator({
+    outputDir,
+    ...options,
+  });
+}