@fincity/kirun-js 3.1.4 → 3.2.0

package/src/engine/dsl/parser/DSLParserError.ts

@@ -0,0 +1,29 @@
+import { DSLToken, SourceLocation } from '../lexer/DSLToken';
+
+/**
+ * Parser error with position information and expected tokens
+ */
+export class DSLParserError extends Error {
+    constructor(
+        message: string,
+        public location?: SourceLocation,
+        public expectedTokens?: string[],
+        public actualToken?: DSLToken,
+    ) {
+        super(message);
+        this.name = 'DSLParserError';
+
+        // Format error message with location if available
+        if (location) {
+            this.message = `${message} at ${location}`;
+        }
+
+        if (expectedTokens && expectedTokens.length > 0) {
+            this.message += `\nExpected: ${expectedTokens.join(', ')}`;
+        }
+
+        if (actualToken) {
+            this.message += `\nActual: ${actualToken.type} (${actualToken.value})`;
+        }
+    }
+}

package/src/engine/dsl/parser/ast/ASTNode.ts

@@ -0,0 +1,23 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+
+/**
+ * Base class for all AST nodes
+ */
+export abstract class ASTNode {
+    constructor(
+        public readonly type: string,
+        public readonly location: SourceLocation,
+    ) {}
+
+    /**
+     * Convert AST node to JSON (for debugging/inspection)
+     */
+    abstract toJSON(): any;
+
+    /**
+     * Pretty-print the AST node
+     */
+    public toString(): string {
+        return JSON.stringify(this.toJSON(), null, 2);
+    }
+}

package/src/engine/dsl/parser/ast/ArgumentNode.ts

@@ -0,0 +1,43 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { ComplexValueNode } from './ComplexValueNode';
+import { ExpressionNode } from './ExpressionNode';
+import { SchemaLiteralNode } from './SchemaLiteralNode';
+
+export type ArgumentValue = ExpressionNode | ComplexValueNode | SchemaLiteralNode;
+
+/**
+ * Argument node - represents a function argument
+ * Can be a single value or multiple values (multi-value parameter)
+ * Each value can be an expression, complex value (object/array), or schema literal
+ */
+export class ArgumentNode extends ASTNode {
+    public values: ArgumentValue[];
+
+    constructor(
+        public key: string,
+        value: ArgumentValue | ArgumentValue[],
+        location: SourceLocation,
+    ) {
+        super('Argument', location);
+        this.values = Array.isArray(value) ? value : [value];
+    }
+
+    /** Get the first (or only) value - for backwards compatibility */
+    public get value(): ArgumentValue {
+        return this.values[0];
+    }
+
+    /** Check if this is a multi-value parameter */
+    public isMultiValue(): boolean {
+        return this.values.length > 1;
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            key: this.key,
+            values: this.values.map((v) => v.toJSON()),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/ComplexValueNode.ts

@@ -0,0 +1,22 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+
+/**
+ * Complex value node - represents literal values
+ * Used for parameter values that are objects, arrays, or primitives (strings, numbers, booleans, null)
+ */
+export class ComplexValueNode extends ASTNode {
+    constructor(
+        public value: any,
+        location: SourceLocation,
+    ) {
+        super('ComplexValue', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            value: this.value,
+        };
+    }
+}

package/src/engine/dsl/parser/ast/EventDeclNode.ts

@@ -0,0 +1,27 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { ParameterDeclNode } from './ParameterDeclNode';
+
+/**
+ * Event declaration node
+ * Example:
+ *   output
+ *       result AS ARRAY OF INTEGER
+ */
+export class EventDeclNode extends ASTNode {
+    constructor(
+        public name: string,
+        public parameters: ParameterDeclNode[] = [],
+        location: SourceLocation,
+    ) {
+        super('EventDecl', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            name: this.name,
+            parameters: this.parameters.map((p) => p.toJSON()),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/ExpressionNode.ts

@@ -0,0 +1,33 @@
+import { Expression } from '../../../runtime/expression/Expression';
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+
+/**
+ * Expression node - wraps KIRun Expression
+ */
+export class ExpressionNode extends ASTNode {
+    public parsedExpression?: Expression;
+
+    constructor(
+        public expressionText: string,
+        location: SourceLocation,
+    ) {
+        super('Expression', location);
+    }
+
+    /**
+     * Parse the expression using KIRun Expression parser
+     */
+    public parse(): void {
+        if (!this.parsedExpression) {
+            this.parsedExpression = new Expression(this.expressionText);
+        }
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            expressionText: this.expressionText,
+        };
+    }
+}

package/src/engine/dsl/parser/ast/FunctionCallNode.ts

@@ -0,0 +1,29 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ArgumentNode } from './ArgumentNode';
+import { ASTNode } from './ASTNode';
+
+/**
+ * Function call node
+ * Example: System.Array.InsertLast(source = Context.a, element = 10)
+ */
+export class FunctionCallNode extends ASTNode {
+    constructor(
+        public namespace: string,
+        public name: string,
+        public argumentsMap: Map<string, ArgumentNode>,
+        location: SourceLocation,
+    ) {
+        super('FunctionCall', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            namespace: this.namespace,
+            name: this.name,
+            arguments: Object.fromEntries(
+                Array.from(this.argumentsMap.entries()).map(([key, arg]) => [key, arg.toJSON()]),
+            ),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/FunctionDefNode.ts

@@ -0,0 +1,37 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { EventDeclNode } from './EventDeclNode';
+import { ParameterDeclNode } from './ParameterDeclNode';
+import { StatementNode } from './StatementNode';
+
+/**
+ * Function definition node - root AST node
+ * Represents the entire function definition
+ */
+export class FunctionDefNode extends ASTNode {
+    constructor(
+        public name: string,
+        public namespace?: string,
+        public parameters: ParameterDeclNode[] = [],
+        public events: EventDeclNode[] = [],
+        public logic: StatementNode[] = [],
+        location?: SourceLocation,
+    ) {
+        super(
+            'FunctionDefinition',
+            location ||
+                new SourceLocation(1, 1, 0, 0), // Default location if not provided
+        );
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            name: this.name,
+            namespace: this.namespace,
+            parameters: this.parameters.map((p) => p.toJSON()),
+            events: this.events.map((e) => e.toJSON()),
+            logic: this.logic.map((s) => s.toJSON()),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/ParameterDeclNode.ts

@@ -0,0 +1,25 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { SchemaNode } from './SchemaNode';
+
+/**
+ * Parameter declaration node
+ * Example: n AS INTEGER
+ */
+export class ParameterDeclNode extends ASTNode {
+    constructor(
+        public name: string,
+        public schema: SchemaNode,
+        location: SourceLocation,
+    ) {
+        super('ParameterDecl', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            name: this.name,
+            schema: this.schema.toJSON(),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/SchemaLiteralNode.ts

@@ -0,0 +1,26 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { ExpressionNode } from './ExpressionNode';
+import { SchemaNode } from './SchemaNode';
+
+/**
+ * Schema literal node - represents inline schema definitions with default values
+ * Example: (ARRAY OF INTEGER) WITH DEFAULT VALUE []
+ */
+export class SchemaLiteralNode extends ASTNode {
+    constructor(
+        public schema: SchemaNode,
+        public defaultValue: ExpressionNode | undefined,
+        location: SourceLocation,
+    ) {
+        super('SchemaLiteral', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            schema: this.schema.toJSON(),
+            defaultValue: this.defaultValue?.toJSON(),
+        };
+    }
+}

package/src/engine/dsl/parser/ast/SchemaNode.ts

@@ -0,0 +1,23 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+
+/**
+ * Schema node - represents a schema specification
+ * Can be either a simple string (e.g., "INTEGER", "ARRAY OF STRING")
+ * or a complex JSON Schema object
+ */
+export class SchemaNode extends ASTNode {
+    constructor(
+        public schemaSpec: string | object,
+        location: SourceLocation,
+    ) {
+        super('Schema', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            schemaSpec: this.schemaSpec,
+        };
+    }
+}

package/src/engine/dsl/parser/ast/StatementNode.ts

@@ -0,0 +1,41 @@
+import { SourceLocation } from '../../lexer/DSLToken';
+import { ASTNode } from './ASTNode';
+import { FunctionCallNode } from './FunctionCallNode';
+
+/**
+ * Statement node - represents a single statement in the LOGIC block
+ * Example:
+ *   create: System.Context.Create(name = "a") AFTER Steps.prev
+ *       iteration
+ *           if: System.If(condition = true)
+ */
+export class StatementNode extends ASTNode {
+    constructor(
+        public statementName: string,
+        public functionCall: FunctionCallNode,
+        public afterSteps: string[] = [],
+        public executeIfSteps: string[] = [],
+        public nestedBlocks: Map<string, StatementNode[]> = new Map(),
+        location: SourceLocation,
+        public comment: string = '',
+    ) {
+        super('Statement', location);
+    }
+
+    public toJSON(): any {
+        return {
+            type: this.type,
+            statementName: this.statementName,
+            functionCall: this.functionCall.toJSON(),
+            afterSteps: this.afterSteps,
+            executeIfSteps: this.executeIfSteps,
+            nestedBlocks: Object.fromEntries(
+                Array.from(this.nestedBlocks.entries()).map(([blockName, statements]) => [
+                    blockName,
+                    statements.map((s) => s.toJSON()),
+                ]),
+            ),
+            comment: this.comment,
+        };
+    }
+}

package/src/engine/dsl/parser/ast/index.ts

@@ -0,0 +1,14 @@
+/**
+ * AST Node exports
+ */
+export { ASTNode } from './ASTNode';
+export { ArgumentNode } from './ArgumentNode';
+export { ComplexValueNode } from './ComplexValueNode';
+export { EventDeclNode } from './EventDeclNode';
+export { ExpressionNode } from './ExpressionNode';
+export { FunctionCallNode } from './FunctionCallNode';
+export { FunctionDefNode } from './FunctionDefNode';
+export { ParameterDeclNode } from './ParameterDeclNode';
+export { SchemaLiteralNode } from './SchemaLiteralNode';
+export { SchemaNode } from './SchemaNode';
+export { StatementNode } from './StatementNode';