@reactive-contracts/compiler 0.1.2-beta → 0.2.0

package/dist/index.cjs

@@ -1,12 +1,108 @@
 'use strict';
 
+var jiti = require('jiti');
+var path2 = require('path');
+var fs = require('fs');
 var promises = require('fs/promises');
-var path = require('path');
+var glob = require('glob');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 
 // 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__namespace.isAbsolute(configPath) ? configPath : path2__namespace.join(cwd, configPath);
+    return fs.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__namespace.join(cwd, name);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadConfig(configPath, cwd = process.cwd()) {
+  const resolvedPath = resolveConfigPath(configPath, cwd);
+  if (!resolvedPath) {
+    return { ...defaultConfig };
+  }
+  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)), {
+    interopDefault: true,
+    moduleCache: false
+    // Disable cache to get fresh config on reload
+  });
+  try {
+    const module = await jiti$1.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) {
@@ -53,17 +149,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`);
@@ -77,46 +173,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`);
       }
     }
   }
@@ -245,10 +341,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);
     }
   }
 }
@@ -413,7 +509,217 @@ export interface ${typeName}Result {
  */
 export const ${typeName}Intent = '${definition.intent}' as const;
 `;
-  await promises.mkdir(path.dirname(outputPath), { recursive: true });
+  await promises.mkdir(path2.dirname(outputPath), { recursive: true });
+  await promises.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 promises.mkdir(path2.dirname(outputPath), { recursive: true });
+  await promises.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 promises.mkdir(path2.dirname(outputPath), { recursive: true });
   await promises.writeFile(outputPath, content, "utf-8");
 }
 function generateTypeDefinitions(shape, typeName) {
@@ -465,10 +771,173 @@ ${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$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)), {
+    interopDefault: true,
+    moduleCache: false
+    // Disable cache to avoid stale imports
+  });
+  try {
+    const module = await jiti$1.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__namespace.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__namespace.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__namespace.join(cwd, config.output.frontend, `${contractName}.ts`);
+    await generateFrontendTypes(contract, frontendPath);
+    generated.frontend = frontendPath;
+    const backendPath = path2__namespace.join(cwd, config.output.backend, `${contractName}.resolver.ts`);
+    await generateBackendResolver(contract, backendPath);
+    generated.backend = backendPath;
+    const runtimePath = path2__namespace.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.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__namespace.isAbsolute(file) ? file : path2__namespace.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__namespace.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__namespace.join(cwd, config.output.frontend, `${contractName}.ts`),
+    backend: path2__namespace.join(cwd, config.output.backend, `${contractName}.resolver.ts`),
+    runtime: path2__namespace.join(cwd, config.output.runtime, `${contractName}.negotiator.ts`)
+  };
+}
 
 exports.analyzeLatency = analyzeLatency;
+exports.compileAll = compileAll;
+exports.compileContract = compileContract;
+exports.consoleLogger = consoleLogger;
 exports.defineConfig = defineConfig;
+exports.findContractFiles = findContractFiles;
+exports.generateBackendResolver = generateBackendResolver;
 exports.generateFrontendTypes = generateFrontendTypes;
+exports.generateRuntimeNegotiator = generateRuntimeNegotiator;
+exports.getGeneratedFilesForContract = getGeneratedFilesForContract;
+exports.isContractFile = isContractFile;
+exports.loadConfig = loadConfig;
+exports.parseContractFile = parseContractFile;
+exports.silentLogger = silentLogger;
 exports.validateContract = validateContract;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map