@reactive-contracts/compiler 0.1.3-beta → 0.2.0

package/dist/index.cli.js

@@ -134,19 +134,84 @@ ${gitignoreTemplate}` : gitignoreTemplate;
 
 // src/cli/commands/compile.ts
 import { glob } from "glob";
-import * as path2 from "path";
-import { createJiti } from "jiti";
+import * as path3 from "path";
+import { createJiti as createJiti2 } from "jiti";
 
 // src/config/index.ts
-async function loadConfig(_configPath = "./rcontracts.config.ts") {
-  return {
-    contracts: "./contracts/**/*.contract.ts",
-    output: {
-      frontend: "./generated/frontend",
-      backend: "./generated/backend",
-      runtime: "./generated/runtime"
+import { createJiti } from "jiti";
+import * as path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+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 resolveConfigPath(configPath, cwd = process.cwd()) {
+  if (configPath) {
+    const absolutePath = path2.isAbsolute(configPath) ? configPath : path2.join(cwd, configPath);
+    return existsSync2(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 (existsSync2(fullPath)) {
+      return fullPath;
     }
-  };
+  }
+  return null;
+}
+async function loadConfig(configPath, cwd = process.cwd()) {
+  const resolvedPath = resolveConfigPath(configPath, cwd);
+  if (!resolvedPath) {
+    return { ...defaultConfig };
+  }
+  const jiti3 = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false
+    // Disable cache to get fresh config on reload
+  });
+  try {
+    const module = await jiti3.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
@@ -194,17 +259,17 @@ function validateContract(contract) {
     warnings
   };
 }
-function validateShape(shape, path4, errors, warnings) {
+function validateShape(shape, path5, errors, warnings) {
   if (!shape || typeof shape !== "object") {
-    errors.push(`Invalid shape at ${path4 || "root"}: must be an object`);
+    errors.push(`Invalid shape at ${path5 || "root"}: must be an object`);
     return;
   }
   const keys = Object.keys(shape);
   if (keys.length === 0) {
-    warnings.push(`Shape at ${path4 || "root"} is empty`);
+    warnings.push(`Shape at ${path5 || "root"} is empty`);
   }
   for (const key of keys) {
-    const fieldPath = path4 ? `${path4}.${key}` : key;
+    const fieldPath = path5 ? `${path5}.${key}` : key;
     const value = shape[key];
     if (!value) {
       errors.push(`Field "${fieldPath}" has undefined value`);
@@ -218,48 +283,48 @@ function validateShape(shape, path4, errors, warnings) {
     validateTypeDefinition(value, fieldPath, errors, warnings);
   }
 }
-function validateTypeDefinition(type, path4, errors, warnings) {
+function validateTypeDefinition(type, path5, 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 ${path4}: "${type}" is not a valid primitive or URL type`);
+      errors.push(`Invalid type at ${path5}: "${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 ${path4}: must be "URL" or "URL<options>"`);
+        errors.push(`Invalid URL type at ${path5}: must be "URL" or "URL<options>"`);
       }
     }
   } else if (typeof type === "object" && type !== null) {
     if ("_brand" in type && type._brand === "DerivedField") {
       validateDerivedField(
         type,
-        path4,
+        path5,
         errors,
         warnings
       );
     } else {
-      validateShape(type, path4, errors, warnings);
+      validateShape(type, path5, errors, warnings);
     }
   } else {
-    errors.push(`Invalid type at ${path4}: must be a string, object, or DerivedField`);
+    errors.push(`Invalid type at ${path5}: must be a string, object, or DerivedField`);
   }
 }
-function validateDerivedField(field, path4, errors, _warnings) {
+function validateDerivedField(field, path5, errors, _warnings) {
   if (typeof field.derive !== "function") {
-    errors.push(`Derived field at ${path4} must have a derive function`);
+    errors.push(`Derived field at ${path5} must have a derive function`);
   }
   if (field.dependencies && !Array.isArray(field.dependencies)) {
-    errors.push(`Derived field dependencies at ${path4} must be an array`);
+    errors.push(`Derived field dependencies at ${path5} must be an array`);
   }
   if (field.preferredLayer && !["client", "edge", "origin"].includes(field.preferredLayer)) {
-    errors.push(`Derived field preferredLayer at ${path4} must be 'client', 'edge', or 'origin'`);
+    errors.push(`Derived field preferredLayer at ${path5} 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 ${path4} must be a string`);
+        errors.push(`Derived field dependency at ${path5} must be a string`);
       }
     }
   }
@@ -388,10 +453,10 @@ function validateVersioning(versioning, errors, warnings) {
 }
 function collectFieldPaths(shape, prefix, result) {
   for (const [key, value] of Object.entries(shape)) {
-    const path4 = prefix ? `${prefix}.${key}` : key;
-    result.add(path4);
+    const path5 = prefix ? `${prefix}.${key}` : key;
+    result.add(path5);
     if (typeof value === "object" && value !== null && !("_brand" in value) && typeof value !== "string") {
-      collectFieldPaths(value, path4, result);
+      collectFieldPaths(value, path5, result);
     }
   }
 }
@@ -824,7 +889,7 @@ ${indentStr}}`;
 }
 
 // src/cli/commands/compile.ts
-var jiti = createJiti(import.meta.url, {
+var jiti = createJiti2(import.meta.url, {
   interopDefault: true,
   moduleCache: false
   // Disable cache to avoid stale imports
@@ -850,7 +915,7 @@ async function compile() {
     let successCount = 0;
     let errorCount = 0;
     for (const file of contractFiles) {
-      const fileName = path2.basename(file, ".contract.ts");
+      const fileName = path3.basename(file, ".contract.ts");
       start(`Processing ${fileName}...`);
       try {
         const module = await jiti.import(file);
@@ -896,19 +961,19 @@ async function compile() {
             }
           }
           const contractName = contract.definition.name;
-          const frontendPath = path2.join(
+          const frontendPath = path3.join(
             process.cwd(),
             config.output.frontend,
             `${contractName}.ts`
           );
           await generateFrontendTypes(contract, frontendPath);
-          const backendPath = path2.join(
+          const backendPath = path3.join(
             process.cwd(),
             config.output.backend,
             `${contractName}.resolver.ts`
           );
           await generateBackendResolver(contract, backendPath);
-          const runtimePath = path2.join(
+          const runtimePath = path3.join(
             process.cwd(),
             config.output.runtime,
             `${contractName}.negotiator.ts`
@@ -942,9 +1007,9 @@ async function compile() {
 
 // src/cli/commands/validate.ts
 import { glob as glob2 } from "glob";
-import * as path3 from "path";
-import { createJiti as createJiti2 } from "jiti";
-var jiti2 = createJiti2(import.meta.url, {
+import * as path4 from "path";
+import { createJiti as createJiti3 } from "jiti";
+var jiti2 = createJiti3(import.meta.url, {
   interopDefault: true,
   moduleCache: false
   // Disable cache to avoid stale imports
@@ -971,7 +1036,7 @@ async function validate() {
     let invalidCount = 0;
     let warningCount = 0;
     for (const file of contractFiles) {
-      const fileName = path3.basename(file, ".contract.ts");
+      const fileName = path4.basename(file, ".contract.ts");
       start(`Validating ${fileName}...`);
       try {
         const module = await jiti2.import(file);

package/dist/index.d.cts

@@ -43,11 +43,52 @@ interface CompilationResult {
 type ConfigDefinition = CompilerConfig;
 
 declare function defineConfig(config: CompilerConfig): ConfigDefinition;
+declare function loadConfig(configPath?: string, cwd?: string): Promise<CompilerConfig>;
 
 declare function validateContract(contract: Contract): ValidationResult;
 
 declare function analyzeLatency(contract: Contract): LatencyAnalysisResult;
 
 declare function generateFrontendTypes(contract: Contract, outputPath: string): Promise<void>;
+declare function generateBackendResolver(contract: Contract, outputPath: string): Promise<void>;
+declare function generateRuntimeNegotiator(contract: Contract, outputPath: string): Promise<void>;
 
-export { type CompilationResult, type CompilerConfig, type ConfigDefinition, type LatencyAnalysisResult, type ValidationResult, analyzeLatency, defineConfig, generateFrontendTypes, validateContract };
+interface CompilerLogger {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+    verbose?: (message: string) => void;
+}
+declare const silentLogger: CompilerLogger;
+declare const consoleLogger: CompilerLogger;
+interface CompileOptions {
+    config: CompilerConfig;
+    cwd?: string;
+    logger?: CompilerLogger;
+    file?: string;
+}
+interface CompileResult {
+    success: boolean;
+    results: CompilationResult[];
+    errors: string[];
+    warnings: string[];
+}
+declare function parseContractFile(filePath: string, logger?: CompilerLogger): Promise<{
+    contracts: Array<{
+        name: string;
+        contract: Contract;
+    }>;
+    errors: string[];
+}>;
+declare function compileContract(contract: Contract, config: CompilerConfig, cwd?: string, logger?: CompilerLogger): Promise<CompilationResult>;
+declare function findContractFiles(config: CompilerConfig, cwd?: string): Promise<string[]>;
+declare function compileAll(options: CompileOptions): Promise<CompileResult>;
+declare function isContractFile(filePath: string): boolean;
+declare function getGeneratedFilesForContract(contractName: string, config: CompilerConfig, cwd?: string): {
+    frontend: string;
+    backend: string;
+    runtime: string;
+};
+
+export { type CompilationResult, type CompileOptions, type CompileResult, type CompilerConfig, type CompilerLogger, type ConfigDefinition, type LatencyAnalysisResult, type ValidationResult, analyzeLatency, compileAll, compileContract, consoleLogger, defineConfig, findContractFiles, generateBackendResolver, generateFrontendTypes, generateRuntimeNegotiator, getGeneratedFilesForContract, isContractFile, loadConfig, parseContractFile, silentLogger, validateContract };

package/dist/index.d.ts

@@ -43,11 +43,52 @@ interface CompilationResult {
 type ConfigDefinition = CompilerConfig;
 
 declare function defineConfig(config: CompilerConfig): ConfigDefinition;
+declare function loadConfig(configPath?: string, cwd?: string): Promise<CompilerConfig>;
 
 declare function validateContract(contract: Contract): ValidationResult;
 
 declare function analyzeLatency(contract: Contract): LatencyAnalysisResult;
 
 declare function generateFrontendTypes(contract: Contract, outputPath: string): Promise<void>;
+declare function generateBackendResolver(contract: Contract, outputPath: string): Promise<void>;
+declare function generateRuntimeNegotiator(contract: Contract, outputPath: string): Promise<void>;
 
-export { type CompilationResult, type CompilerConfig, type ConfigDefinition, type LatencyAnalysisResult, type ValidationResult, analyzeLatency, defineConfig, generateFrontendTypes, validateContract };
+interface CompilerLogger {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+    verbose?: (message: string) => void;
+}
+declare const silentLogger: CompilerLogger;
+declare const consoleLogger: CompilerLogger;
+interface CompileOptions {
+    config: CompilerConfig;
+    cwd?: string;
+    logger?: CompilerLogger;
+    file?: string;
+}
+interface CompileResult {
+    success: boolean;
+    results: CompilationResult[];
+    errors: string[];
+    warnings: string[];
+}
+declare function parseContractFile(filePath: string, logger?: CompilerLogger): Promise<{
+    contracts: Array<{
+        name: string;
+        contract: Contract;
+    }>;
+    errors: string[];
+}>;
+declare function compileContract(contract: Contract, config: CompilerConfig, cwd?: string, logger?: CompilerLogger): Promise<CompilationResult>;
+declare function findContractFiles(config: CompilerConfig, cwd?: string): Promise<string[]>;
+declare function compileAll(options: CompileOptions): Promise<CompileResult>;
+declare function isContractFile(filePath: string): boolean;
+declare function getGeneratedFilesForContract(contractName: string, config: CompilerConfig, cwd?: string): {
+    frontend: string;
+    backend: string;
+    runtime: string;
+};
+
+export { type CompilationResult, type CompileOptions, type CompileResult, type CompilerConfig, type CompilerLogger, type ConfigDefinition, type LatencyAnalysisResult, type ValidationResult, analyzeLatency, compileAll, compileContract, consoleLogger, defineConfig, findContractFiles, generateBackendResolver, generateFrontendTypes, generateRuntimeNegotiator, getGeneratedFilesForContract, isContractFile, loadConfig, parseContractFile, silentLogger, validateContract };