Refactor Wrapper to Injected Service (WrapperFactory)

apps/docs/generator/src/main.ts

@@ -35,6 +35,7 @@ function generateBlockTypeDocs(
 ): void {
   const blockTypes = getAllBuiltinBlocktypes(
     services.shared.workspace.LangiumDocuments,
+    services.WrapperFactory,
   );
 
   const docsPath = join(
@@ -72,6 +73,7 @@ function generateConstraintTypeDocs(
   );
   const constraintTypes = getAllBuiltinConstraintTypes(
     services.shared.workspace.LangiumDocuments,
+    services.WrapperFactory,
   );
 
   for (const constraintType of constraintTypes) {

libs/execution/src/lib/blocks/block-execution-util.ts

@@ -6,7 +6,6 @@ import {
   BlockDefinition,
   CompositeBlocktypeDefinition,
   PipelineDefinition,
-  PipelineWrapper,
 } from '@jvalue/jayvee-language-server';
 
 import { type ExecutionContext } from '../execution-context';
@@ -34,7 +33,8 @@ export async function executeBlocks(
   pipesContainer: CompositeBlocktypeDefinition | PipelineDefinition,
   initialInputValue: IOTypeImplementation | undefined = undefined,
 ): Promise<R.Result<ExecutionOrderItem[]>> {
-  const pipelineWrapper = new PipelineWrapper(pipesContainer);
+  const pipelineWrapper =
+    executionContext.wrapperFactory.Pipeline.wrap(pipesContainer);
   const executionOrder: {
     block: BlockDefinition;
     value: IOTypeImplementation | null;

libs/execution/src/lib/blocks/composite-block-executor.ts

@@ -13,6 +13,7 @@ import {
   IOType,
   InternalValueRepresentation,
   Valuetype,
+  WrapperFactory,
   createValuetype,
   evaluateExpression,
   evaluatePropertyValue,
@@ -133,6 +134,7 @@ export function createCompositeBlockExecutor(
           block,
           properties,
           context.evaluationContext,
+          context.wrapperFactory,
         );
 
         assert(
@@ -153,6 +155,7 @@ export function createCompositeBlockExecutor(
       block: BlockDefinition,
       properties: BlocktypeProperty[],
       evaluationContext: EvaluationContext,
+      wrapperFactory: WrapperFactory,
     ): InternalValueRepresentation | undefined {
       const propertyFromBlock = block.body.properties.find(
         (property) => property.name === name,
@@ -162,6 +165,7 @@ export function createCompositeBlockExecutor(
         const value = evaluatePropertyValue(
           propertyFromBlock,
           evaluationContext,
+          wrapperFactory,
           valueType,
         );
 
@@ -181,6 +185,7 @@ export function createCompositeBlockExecutor(
       return evaluateExpression(
         propertyFromBlockType.defaultValue,
         evaluationContext,
+        wrapperFactory,
       );
     }
   };

libs/execution/src/lib/constraints/default-constraint-executors-extension.spec.ts

@@ -21,6 +21,7 @@ describe('default constraint extension', () => {
 
     getAllBuiltinConstraintTypes(
       services.shared.workspace.LangiumDocuments,
+      services.WrapperFactory,
     ).forEach((constraintType) => {
       const matchingConstraintExecutorClass = defaultConstraintExtension
         .getConstraintExecutors()

libs/execution/src/lib/constraints/executors/expression-constraint-executor.ts

@@ -28,7 +28,11 @@ export class ExpressionConstraintExecutor
 
     context.evaluationContext.setValueForValueKeyword(value);
 
-    const result = evaluateExpression(expression, context.evaluationContext);
+    const result = evaluateExpression(
+      expression,
+      context.evaluationContext,
+      context.wrapperFactory,
+    );
     assert(PrimitiveValuetypes.Boolean.isInternalValueRepresentation(result));
 
     context.evaluationContext.deleteValueForValueKeyword();

libs/execution/src/lib/execution-context.ts

@@ -6,15 +6,14 @@ import { strict as assert } from 'assert';
 
 import {
   BlockDefinition,
-  BlockTypeWrapper,
   ConstraintDefinition,
-  ConstraintTypeWrapper,
   EvaluationContext,
   InternalValueRepresentation,
   PipelineDefinition,
   PropertyAssignment,
   TransformDefinition,
   Valuetype,
+  type WrapperFactory,
   evaluatePropertyValue,
   isBlockDefinition,
   isExpressionConstraintDefinition,
@@ -46,6 +45,7 @@ export class ExecutionContext {
     public readonly executionExtension: JayveeExecExtension,
     public readonly constraintExtension: JayveeConstraintExtension,
     public readonly logger: Logger,
+    public readonly wrapperFactory: WrapperFactory,
     public readonly runOptions: {
       isDebugMode: boolean;
       debugGranularity: DebugGranularity;
@@ -99,6 +99,7 @@ export class ExecutionContext {
     const propertyValue = evaluatePropertyValue(
       property,
       this.evaluationContext,
+      this.wrapperFactory,
       valuetype,
     );
     assert(propertyValue !== undefined);
@@ -152,21 +153,9 @@ export class ExecutionContext {
 
     assert(isReference(currentNode.type));
     if (isTypedConstraintDefinition(currentNode)) {
-      assert(
-        ConstraintTypeWrapper.canBeWrapped(currentNode.type),
-        `ConstraintType ${
-          currentNode.type.ref?.name ?? '<unresolved reference>'
-        } cannot be wrapped`,
-      );
-      return new ConstraintTypeWrapper(currentNode.type);
+      return this.wrapperFactory.ConstraintType.wrap(currentNode.type);
     } else if (isBlockDefinition(currentNode)) {
-      assert(
-        BlockTypeWrapper.canBeWrapped(currentNode.type),
-        `Blocktype ${
-          currentNode.type.ref?.name ?? '<unresolved reference>'
-        } cannot be wrapped`,
-      );
-      return new BlockTypeWrapper(currentNode.type);
+      return this.wrapperFactory.BlockType.wrap(currentNode.type);
     }
     assertUnreachable(currentNode);
   }

libs/execution/src/lib/transforms/transform-executor.ts

@@ -100,6 +100,7 @@ export class TransformExecutor {
         newValue = evaluateExpression(
           this.getOutputAssignment().expression,
           context.evaluationContext,
+          context.wrapperFactory,
         );
       } catch (e) {
         if (e instanceof Error) {

libs/execution/src/lib/types/valuetypes/value-representation-validity.ts

@@ -50,6 +50,7 @@ class ValueRepresentationValidityVisitor extends ValuetypeVisitor<boolean> {
 
     const constraints = valuetype.getConstraints(
       this.context.evaluationContext,
+      this.context.wrapperFactory,
     );
     for (const constraint of constraints) {
       const constraintExecutor =

libs/execution/test/utils/test-infrastructure-util.ts

@@ -3,9 +3,11 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
 import {
+  DefaultOperatorEvaluatorRegistry,
   EvaluationContext,
   PipelineDefinition,
   RuntimeParameterProvider,
+  WrapperFactory,
 } from '@jvalue/jayvee-language-server';
 import { AstNode, AstNodeLocator, LangiumDocument } from 'langium';
 
@@ -55,13 +57,19 @@ export function getTestExecutionContext(
     'pipelines@0',
   ) as PipelineDefinition;
 
+  const operatorEvaluatorRegistry = new DefaultOperatorEvaluatorRegistry();
+
   const executionContext = new ExecutionContext(
     pipeline,
     new TestExecExtension(),
     new DefaultConstraintExtension(),
     new CachedLogger(runOptions.isDebugMode, undefined, loggerPrintLogs),
+    new WrapperFactory(operatorEvaluatorRegistry),
     runOptions,
-    new EvaluationContext(new RuntimeParameterProvider()),
+    new EvaluationContext(
+      new RuntimeParameterProvider(),
+      operatorEvaluatorRegistry,
+    ),
   );
 
   initialStack.forEach((node) => executionContext.enterNode(node));

libs/interpreter-lib/src/interpreter.ts

@@ -24,8 +24,10 @@ import {
   JayveeModel,
   JayveeServices,
   PipelineDefinition,
-  PipelineWrapper,
+  RuntimeParameterLiteral,
   RuntimeParameterProvider,
+  ValidationContext,
+  WrapperFactory,
   createJayveeServices,
   initializeWorkspace,
   internalValueToString,
@@ -136,7 +138,7 @@ export async function interpretModel(
     model,
     new StdExecExtension(),
     new DefaultConstraintExtension(),
-    services.RuntimeParameterProvider,
+    services,
     loggerFactory,
     {
       debug: options.debug,
@@ -158,7 +160,17 @@ function setupJayveeServices(
   );
 
   services.validation.ValidationRegistry.registerJayveeValidationChecks({
-    RuntimeParameterLiteral: validateRuntimeParameterLiteral,
+    RuntimeParameterLiteral: (
+      runtimeParameter: RuntimeParameterLiteral,
+      validationContext: ValidationContext,
+      evaluationContext: EvaluationContext,
+    ) =>
+      validateRuntimeParameterLiteral(
+        runtimeParameter,
+        validationContext,
+        evaluationContext,
+        services.WrapperFactory,
+      ),
   });
 }
 
@@ -177,7 +189,7 @@ async function interpretJayveeModel(
   model: JayveeModel,
   executionExtension: JayveeExecExtension,
   constraintExtension: JayveeConstraintExtension,
-  runtimeParameterProvider: RuntimeParameterProvider,
+  jayveeServices: JayveeServices,
   loggerFactory: LoggerFactory,
   runOptions: InterpreterOptions,
 ): Promise<ExitCode> {
@@ -186,7 +198,7 @@ async function interpretJayveeModel(
       pipeline,
       executionExtension,
       constraintExtension,
-      runtimeParameterProvider,
+      jayveeServices,
       loggerFactory,
       runOptions,
     );
@@ -203,7 +215,7 @@ async function runPipeline(
   pipeline: PipelineDefinition,
   executionExtension: JayveeExecExtension,
   constraintExtension: JayveeConstraintExtension,
-  runtimeParameterProvider: RuntimeParameterProvider,
+  jayveeServices: JayveeServices,
   loggerFactory: LoggerFactory,
   runOptions: InterpreterOptions,
 ): Promise<ExitCode> {
@@ -212,18 +224,23 @@ async function runPipeline(
     executionExtension,
     constraintExtension,
     loggerFactory.createLogger(),
+    jayveeServices.WrapperFactory,
     {
       isDebugMode: runOptions.debug,
       debugGranularity: runOptions.debugGranularity,
       debugTargets: runOptions.debugTargets,
     },
-    new EvaluationContext(runtimeParameterProvider),
+    new EvaluationContext(
+      jayveeServices.RuntimeParameterProvider,
+      jayveeServices.operators.EvaluatorRegistry,
+    ),
   );
 
   logPipelineOverview(
     pipeline,
-    runtimeParameterProvider,
+    jayveeServices.RuntimeParameterProvider,
     executionContext.logger,
+    jayveeServices.WrapperFactory,
   );
 
   const startTime = new Date();
@@ -248,8 +265,9 @@ export function logPipelineOverview(
   pipeline: PipelineDefinition,
   runtimeParameterProvider: RuntimeParameterProvider,
   logger: Logger,
+  wrapperFactory: WrapperFactory,
 ) {
-  const pipelineWrapper = new PipelineWrapper(pipeline);
+  const pipelineWrapper = wrapperFactory.Pipeline.wrap(pipeline);
 
   const toString = (block: BlockDefinition, depth = 0): string => {
     const blockTypeName = block.type.ref?.name;

libs/interpreter-lib/src/std-extension.spec.ts

@@ -16,7 +16,10 @@ import { NodeFileSystem } from 'langium/node';
 async function loadAllBuiltinBlocktypes(): Promise<BlockTypeWrapper[]> {
   const services = createJayveeServices(NodeFileSystem).Jayvee;
   await initializeWorkspace(services);
-  return getAllBuiltinBlocktypes(services.shared.workspace.LangiumDocuments);
+  return getAllBuiltinBlocktypes(
+    services.shared.workspace.LangiumDocuments,
+    services.WrapperFactory,
+  );
 }
 
 describe('std extension', () => {

libs/interpreter-lib/src/validation-checks/runtime-parameter-literal.spec.ts

@@ -6,10 +6,13 @@ import * as path from 'path';
 
 import { parseValueToInternalRepresentation } from '@jvalue/jayvee-execution';
 import {
+  DefaultOperatorEvaluatorRegistry,
+  DefaultOperatorTypeComputerRegistry,
   EvaluationContext,
   RuntimeParameterLiteral,
   RuntimeParameterProvider,
   ValidationContext,
+  WrapperFactory,
   createJayveeServices,
 } from '@jvalue/jayvee-language-server';
 import {
@@ -60,10 +63,19 @@ describe('Validation of validateRuntimeParameterLiteral', () => {
       }
     }
 
+    const operatorEvaluatorRegistry = new DefaultOperatorEvaluatorRegistry();
+    const operatorTypeComputerRegistry =
+      new DefaultOperatorTypeComputerRegistry();
+    const wrapperFactory = new WrapperFactory(operatorEvaluatorRegistry);
+
     validateRuntimeParameterLiteral(
       runtimeParameter,
-      new ValidationContext(validationAcceptorMock),
-      new EvaluationContext(runtimeProvider),
+      new ValidationContext(
+        validationAcceptorMock,
+        operatorTypeComputerRegistry,
+      ),
+      new EvaluationContext(runtimeProvider, operatorEvaluatorRegistry),
+      wrapperFactory,
     );
   }
 

libs/interpreter-lib/src/validation-checks/runtime-parameter-literal.ts

@@ -9,14 +9,15 @@ import {
   ReferenceableBlocktypeDefinition,
   RuntimeParameterLiteral,
   ValidationContext,
-  getTypedObjectWrapper,
+  type WrapperFactory,
 } from '@jvalue/jayvee-language-server';
 import { Reference } from 'langium';
 
 export function validateRuntimeParameterLiteral(
   runtimeParameter: RuntimeParameterLiteral,
   validationContext: ValidationContext,
   evaluationContext: EvaluationContext,
+  wrapperFactory: WrapperFactory,
 ) {
   checkRuntimeParameterValuePresence(
     runtimeParameter,
@@ -31,6 +32,7 @@ export function validateRuntimeParameterLiteral(
     runtimeParameter,
     validationContext,
     evaluationContext,
+    wrapperFactory,
   );
 }
 
@@ -59,6 +61,7 @@ function checkRuntimeParameterValueParsing(
   runtimeParameter: RuntimeParameterLiteral,
   validationContext: ValidationContext,
   evaluationContext: EvaluationContext,
+  wrapperFactory: WrapperFactory,
 ) {
   const enclosingPropertyBody = getEnclosingPropertyBody(runtimeParameter);
   const type:
@@ -67,7 +70,7 @@ function checkRuntimeParameterValueParsing(
     | undefined =
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     enclosingPropertyBody.$container?.type;
-  const wrapper = getTypedObjectWrapper(type);
+  const wrapper = wrapperFactory.wrapTypedObject(type);
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   const propertyName = runtimeParameter.$container?.name;