@reactive-contracts/compiler 0.1.3-beta → 0.2.0

package/dist/index.js

@@ -1,10 +1,86 @@
-import { mkdir, writeFile } from 'fs/promises';
+import { createJiti } from 'jiti';
+import * as path2 from 'path';
 import { dirname } from 'path';
+import { existsSync } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
+import { glob } from 'glob';
 
 // src/config/index.ts
+var defaultConfig = {
+  contracts: "./contracts/**/*.contract.ts",
+  output: {
+    frontend: "./generated/frontend",
+    backend: "./generated/backend",
+    runtime: "./generated/runtime"
+  },
+  validation: {
+    strictLatency: false,
+    requireIntent: true,
+    maxComplexity: 10
+  },
+  optimization: {
+    bundleSplitting: false,
+    treeShaking: false,
+    precompute: []
+  }
+};
 function defineConfig(config) {
   return config;
 }
+function resolveConfigPath(configPath, cwd = process.cwd()) {
+  if (configPath) {
+    const absolutePath = path2.isAbsolute(configPath) ? configPath : path2.join(cwd, configPath);
+    return existsSync(absolutePath) ? absolutePath : null;
+  }
+  const configNames = [
+    "rcontracts.config.ts",
+    "rcontracts.config.js",
+    "rcontracts.config.mjs",
+    "reactive-contracts.config.ts",
+    "reactive-contracts.config.js"
+  ];
+  for (const name of configNames) {
+    const fullPath = path2.join(cwd, name);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadConfig(configPath, cwd = process.cwd()) {
+  const resolvedPath = resolveConfigPath(configPath, cwd);
+  if (!resolvedPath) {
+    return { ...defaultConfig };
+  }
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false
+    // Disable cache to get fresh config on reload
+  });
+  try {
+    const module = await jiti.import(resolvedPath);
+    const config = module.default || module;
+    return {
+      ...defaultConfig,
+      ...config,
+      output: {
+        ...defaultConfig.output,
+        ...config.output || {}
+      },
+      validation: {
+        ...defaultConfig.validation,
+        ...config.validation || {}
+      },
+      optimization: {
+        ...defaultConfig.optimization,
+        ...config.optimization || {}
+      }
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load config from ${resolvedPath}: ${errorMessage}`);
+  }
+}
 
 // src/validator/index.ts
 function validateContract(contract) {
@@ -51,17 +127,17 @@ function validateContract(contract) {
     warnings
   };
 }
-function validateShape(shape, path, errors, warnings) {
+function validateShape(shape, path3, errors, warnings) {
   if (!shape || typeof shape !== "object") {
-    errors.push(`Invalid shape at ${path || "root"}: must be an object`);
+    errors.push(`Invalid shape at ${path3 || "root"}: must be an object`);
     return;
   }
   const keys = Object.keys(shape);
   if (keys.length === 0) {
-    warnings.push(`Shape at ${path || "root"} is empty`);
+    warnings.push(`Shape at ${path3 || "root"} is empty`);
   }
   for (const key of keys) {
-    const fieldPath = path ? `${path}.${key}` : key;
+    const fieldPath = path3 ? `${path3}.${key}` : key;
     const value = shape[key];
     if (!value) {
       errors.push(`Field "${fieldPath}" has undefined value`);
@@ -75,46 +151,46 @@ function validateShape(shape, path, errors, warnings) {
     validateTypeDefinition(value, fieldPath, errors, warnings);
   }
 }
-function validateTypeDefinition(type, path, errors, warnings) {
+function validateTypeDefinition(type, path3, errors, warnings) {
   if (typeof type === "string") {
     const validPrimitives = ["string", "number", "boolean", "Date", "null", "undefined"];
     const isURL = type === "URL" || type.startsWith("URL<");
     if (!validPrimitives.includes(type) && !isURL) {
-      errors.push(`Invalid type at ${path}: "${type}" is not a valid primitive or URL type`);
+      errors.push(`Invalid type at ${path3}: "${type}" is not a valid primitive or URL type`);
     }
     if (isURL && type !== "URL") {
       const urlMatch = type.match(/^URL<(.+)>$/);
       if (!urlMatch) {
-        errors.push(`Invalid URL type at ${path}: must be "URL" or "URL<options>"`);
+        errors.push(`Invalid URL type at ${path3}: must be "URL" or "URL<options>"`);
       }
     }
   } else if (typeof type === "object" && type !== null) {
     if ("_brand" in type && type._brand === "DerivedField") {
       validateDerivedField(
         type,
-        path,
+        path3,
         errors);
     } else {
-      validateShape(type, path, errors, warnings);
+      validateShape(type, path3, errors, warnings);
     }
   } else {
-    errors.push(`Invalid type at ${path}: must be a string, object, or DerivedField`);
+    errors.push(`Invalid type at ${path3}: must be a string, object, or DerivedField`);
   }
 }
-function validateDerivedField(field, path, errors, _warnings) {
+function validateDerivedField(field, path3, errors, _warnings) {
   if (typeof field.derive !== "function") {
-    errors.push(`Derived field at ${path} must have a derive function`);
+    errors.push(`Derived field at ${path3} must have a derive function`);
   }
   if (field.dependencies && !Array.isArray(field.dependencies)) {
-    errors.push(`Derived field dependencies at ${path} must be an array`);
+    errors.push(`Derived field dependencies at ${path3} must be an array`);
   }
   if (field.preferredLayer && !["client", "edge", "origin"].includes(field.preferredLayer)) {
-    errors.push(`Derived field preferredLayer at ${path} must be 'client', 'edge', or 'origin'`);
+    errors.push(`Derived field preferredLayer at ${path3} must be 'client', 'edge', or 'origin'`);
   }
   if (field.dependencies && Array.isArray(field.dependencies)) {
     for (const dep of field.dependencies) {
       if (typeof dep !== "string") {
-        errors.push(`Derived field dependency at ${path} must be a string`);
+        errors.push(`Derived field dependency at ${path3} must be a string`);
       }
     }
   }
@@ -243,10 +319,10 @@ function validateVersioning(versioning, errors, warnings) {
 }
 function collectFieldPaths(shape, prefix, result) {
   for (const [key, value] of Object.entries(shape)) {
-    const path = prefix ? `${prefix}.${key}` : key;
-    result.add(path);
+    const path3 = prefix ? `${prefix}.${key}` : key;
+    result.add(path3);
     if (typeof value === "object" && value !== null && !("_brand" in value) && typeof value !== "string") {
-      collectFieldPaths(value, path, result);
+      collectFieldPaths(value, path3, result);
     }
   }
 }
@@ -414,6 +490,216 @@ export const ${typeName}Intent = '${definition.intent}' as const;
   await mkdir(dirname(outputPath), { recursive: true });
   await writeFile(outputPath, content, "utf-8");
 }
+async function generateBackendResolver(contract, outputPath) {
+  const { definition } = contract;
+  const typeName = definition.name;
+  const shapeType = generateTypeDefinitions(definition.shape, `${typeName}ResolverShape`);
+  const content = `/**
+ * Auto-generated resolver template for ${typeName} contract
+ * Generated by @reactive-contracts/compiler
+ *
+ * Intent: ${definition.intent}
+ */
+
+import { implementContract } from '@reactive-contracts/server';
+import type { Contract } from '@reactive-contracts/core';
+import type { ResolverContext } from '@reactive-contracts/server';
+
+${shapeType}
+
+/**
+ * Implement the ${typeName} contract resolver
+ *
+ * This function should return data matching the contract shape.
+ * Derived fields will be computed automatically - don't include them.
+ */
+export const ${typeName}Resolver = implementContract(
+  // Import your contract definition here
+  {} as Contract, // Replace with your contract
+  {
+    async resolve(params: Record<string, unknown>, context: ResolverContext): Promise<${typeName}ResolverShape> {
+      // TODO: Implement your data fetching logic here
+
+      // Example:
+      // const data = await db.query(...);
+      // return {
+      //   // Map your data to match the contract shape
+      // };
+
+      throw new Error('${typeName}Resolver not implemented yet');
+    },
+
+    // Optional: Configure caching
+    cache: {
+      ttl: '5m',
+      staleWhileRevalidate: '1h',
+      tags: (params) => [\`${typeName.toLowerCase()}:\${params.id}\`],
+    },
+  }
+);
+`;
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
+async function generateRuntimeNegotiator(contract, outputPath) {
+  const { definition } = contract;
+  const typeName = definition.name;
+  const content = `/**
+ * Auto-generated runtime negotiator for ${typeName} contract
+ * DO NOT EDIT - This file is generated by @reactive-contracts/compiler
+ */
+
+import type { Contract } from '@reactive-contracts/core';
+
+/**
+ * Runtime negotiator for ${typeName}
+ * Handles SLA monitoring, fallback logic, and performance tracking
+ */
+export class ${typeName}Negotiator {
+  private contract: Contract;
+  private metrics: {
+    executionTime: number[];
+    cacheHits: number;
+    cacheMisses: number;
+  } = {
+    executionTime: [],
+    cacheHits: 0,
+    cacheMisses: 0,
+  };
+
+  constructor(contract: Contract) {
+    this.contract = contract;
+  }
+
+  /**
+   * Execute contract with SLA monitoring
+   */
+  async execute<TData>(
+    resolver: () => Promise<TData>,
+    options?: {
+      useCache?: boolean;
+      timeout?: number;
+    }
+  ): Promise<{
+    data: TData;
+    status: {
+      latency: 'normal' | 'degraded' | 'violated';
+      freshness: 'fresh' | 'stale' | 'expired';
+      availability: 'available' | 'degraded' | 'unavailable';
+    };
+    metadata: {
+      executionTime: number;
+      cacheHit: boolean;
+      derivedAt: 'client' | 'edge' | 'origin';
+    };
+  }> {
+    const startTime = performance.now();
+
+    try {
+      // Execute resolver
+      const data = await resolver();
+      const executionTime = performance.now() - startTime;
+
+      // Track metrics
+      this.metrics.executionTime.push(executionTime);
+      if (options?.useCache) {
+        this.metrics.cacheHits++;
+      } else {
+        this.metrics.cacheMisses++;
+      }
+
+      // Determine latency status
+      const maxLatency = this.getMaxLatency();
+      const latencyStatus = this.evaluateLatency(executionTime, maxLatency);
+
+      return {
+        data,
+        status: {
+          latency: latencyStatus,
+          freshness: 'fresh',
+          availability: 'available',
+        },
+        metadata: {
+          executionTime,
+          cacheHit: options?.useCache ?? false,
+          derivedAt: 'origin',
+        },
+      };
+    } catch (error) {
+      // Handle fallback based on contract constraints
+      throw error;
+    }
+  }
+
+  /**
+   * Get metrics for monitoring
+   */
+  getMetrics() {
+    const avgExecutionTime =
+      this.metrics.executionTime.length > 0
+        ? this.metrics.executionTime.reduce((a, b) => a + b, 0) / this.metrics.executionTime.length
+        : 0;
+
+    return {
+      averageExecutionTime: avgExecutionTime,
+      p95ExecutionTime: this.calculateP95(),
+      cacheHitRate:
+        this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses) || 0,
+      totalExecutions: this.metrics.executionTime.length,
+    };
+  }
+
+  private getMaxLatency(): number {
+    const latency = this.contract.definition.constraints?.latency?.max;
+    if (!latency) return Infinity;
+
+    // Simple parsing for MVP
+    const match = latency.match(/^(\\d+)(ms|s|m)$/);
+    if (!match) return Infinity;
+
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+
+    switch (unit) {
+      case 'ms': return value;
+      case 's': return value * 1000;
+      case 'm': return value * 60 * 1000;
+      default: return Infinity;
+    }
+  }
+
+  private evaluateLatency(
+    executionTime: number,
+    maxLatency: number
+  ): 'normal' | 'degraded' | 'violated' {
+    if (executionTime <= maxLatency) {
+      return 'normal';
+    } else if (executionTime <= maxLatency * 1.5) {
+      return 'degraded';
+    } else {
+      return 'violated';
+    }
+  }
+
+  private calculateP95(): number {
+    if (this.metrics.executionTime.length === 0) return 0;
+
+    const sorted = [...this.metrics.executionTime].sort((a, b) => a - b);
+    const index = Math.floor(sorted.length * 0.95);
+    return sorted[index];
+  }
+}
+
+/**
+ * Create a new negotiator instance
+ */
+export function create${typeName}Negotiator(contract: Contract): ${typeName}Negotiator {
+  return new ${typeName}Negotiator(contract);
+}
+`;
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
 function generateTypeDefinitions(shape, typeName) {
   const fields = generateShapeFields(shape, 0);
   return `export interface ${typeName} {
@@ -463,7 +749,159 @@ ${indentStr}}`;
   }
   return "any";
 }
+var silentLogger = {
+  info: () => {
+  },
+  success: () => {
+  },
+  warning: () => {
+  },
+  error: () => {
+  },
+  verbose: () => {
+  }
+};
+var consoleLogger = {
+  info: (msg) => console.log("[rcontracts]", msg),
+  success: (msg) => console.log("[rcontracts] \u2713", msg),
+  warning: (msg) => console.warn("[rcontracts] \u26A0", msg),
+  error: (msg) => console.error("[rcontracts] \u2717", msg),
+  verbose: (msg) => console.log("[rcontracts]", msg)
+};
+async function parseContractFile(filePath, logger = silentLogger) {
+  const contracts = [];
+  const errors = [];
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false
+    // Disable cache to avoid stale imports
+  });
+  try {
+    const module = await jiti.import(filePath);
+    const contractExports = Object.entries(module).filter(
+      ([key, value]) => key.endsWith("Contract") && typeof value === "object" && value !== null && "_brand" in value && value._brand === "Contract"
+    );
+    if (contractExports.length === 0) {
+      errors.push(`No contract found in ${path2.basename(filePath)}`);
+      return { contracts, errors };
+    }
+    for (const [exportName, contractObj] of contractExports) {
+      contracts.push({
+        name: exportName,
+        contract: contractObj
+      });
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    errors.push(`Failed to parse ${path2.basename(filePath)}: ${errorMessage}`);
+    logger.error?.(errorMessage);
+  }
+  return { contracts, errors };
+}
+async function compileContract(contract, config, cwd = process.cwd(), logger = silentLogger) {
+  const validation = validateContract(contract);
+  const latency = analyzeLatency(contract);
+  const generated = {};
+  for (const warn of validation.warnings) {
+    logger.warning?.(warn);
+  }
+  if (!validation.valid) {
+    for (const err of validation.errors) {
+      logger.error?.(err);
+    }
+    return { contract, validation, latency, generated };
+  }
+  if (latency.status === "error") {
+    logger.error?.(latency.message || "Latency analysis failed");
+    if (config.validation?.strictLatency) {
+      return { contract, validation, latency, generated };
+    }
+  } else if (latency.status === "warning") {
+    logger.warning?.(latency.message || "Latency constraint may not be met");
+  }
+  if (latency.suggestions?.length) {
+    for (const suggestion of latency.suggestions) {
+      logger.info?.(`\u{1F4A1} ${suggestion}`);
+    }
+  }
+  const contractName = contract.definition.name;
+  try {
+    const frontendPath = path2.join(cwd, config.output.frontend, `${contractName}.ts`);
+    await generateFrontendTypes(contract, frontendPath);
+    generated.frontend = frontendPath;
+    const backendPath = path2.join(cwd, config.output.backend, `${contractName}.resolver.ts`);
+    await generateBackendResolver(contract, backendPath);
+    generated.backend = backendPath;
+    const runtimePath = path2.join(cwd, config.output.runtime, `${contractName}.negotiator.ts`);
+    await generateRuntimeNegotiator(contract, runtimePath);
+    generated.runtime = runtimePath;
+    logger.success?.(`Generated code for ${contractName}`);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    logger.error?.(`Failed to generate code for ${contractName}: ${errorMessage}`);
+    validation.errors.push(errorMessage);
+    validation.valid = false;
+  }
+  return { contract, validation, latency, generated };
+}
+async function findContractFiles(config, cwd = process.cwd()) {
+  return glob(config.contracts, {
+    cwd,
+    absolute: true
+  });
+}
+async function compileAll(options) {
+  const { config, cwd = process.cwd(), logger = silentLogger, file } = options;
+  const results = [];
+  const errors = [];
+  const warnings = [];
+  let contractFiles;
+  if (file) {
+    contractFiles = [path2.isAbsolute(file) ? file : path2.join(cwd, file)];
+  } else {
+    contractFiles = await findContractFiles(config, cwd);
+  }
+  if (contractFiles.length === 0) {
+    errors.push(`No contract files found matching pattern: ${config.contracts}`);
+    return { success: false, results, errors, warnings };
+  }
+  logger.info?.(`Found ${contractFiles.length} contract file(s)`);
+  for (const filePath of contractFiles) {
+    const fileName = path2.basename(filePath, ".contract.ts");
+    logger.verbose?.(`Processing ${fileName}...`);
+    const { contracts, errors: parseErrors } = await parseContractFile(filePath, logger);
+    if (parseErrors.length > 0) {
+      errors.push(...parseErrors);
+      continue;
+    }
+    for (const { name, contract } of contracts) {
+      const result = await compileContract(contract, config, cwd, logger);
+      results.push(result);
+      if (!result.validation.valid) {
+        errors.push(`Validation failed for ${name}`);
+      }
+      warnings.push(...result.validation.warnings);
+    }
+  }
+  const success = errors.length === 0;
+  if (success) {
+    logger.success?.(`Successfully compiled ${results.length} contract(s)`);
+  } else {
+    logger.error?.(`Compilation failed with ${errors.length} error(s)`);
+  }
+  return { success, results, errors, warnings };
+}
+function isContractFile(filePath) {
+  return filePath.endsWith(".contract.ts");
+}
+function getGeneratedFilesForContract(contractName, config, cwd = process.cwd()) {
+  return {
+    frontend: path2.join(cwd, config.output.frontend, `${contractName}.ts`),
+    backend: path2.join(cwd, config.output.backend, `${contractName}.resolver.ts`),
+    runtime: path2.join(cwd, config.output.runtime, `${contractName}.negotiator.ts`)
+  };
+}
 
-export { analyzeLatency, defineConfig, generateFrontendTypes, validateContract };
+export { analyzeLatency, compileAll, compileContract, consoleLogger, defineConfig, findContractFiles, generateBackendResolver, generateFrontendTypes, generateRuntimeNegotiator, getGeneratedFilesForContract, isContractFile, loadConfig, parseContractFile, silentLogger, validateContract };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactive-contracts/compiler",
-  "version": "0.1.3-beta",
+  "version": "0.2.0",
   "description": "Build-time compiler and validator for Reactive Contracts",
   "type": "module",
   "bin": {