@enspirit/elo 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bernard Lambeau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,322 @@
+# What is Elo ?
+
+[![CI](https://github.com/enspirit/elo/actions/workflows/ci.yml/badge.svg)](https://github.com/enspirit/elo/actions/workflows/ci.yml)
+
+A simple, well-designed, portable and safe data expression language that
+compiles to Ruby, Javascript and PostgreSQL.
+
+**[Try Elo online](https://elo-lang.org/)** - Interactive playground and documentation
+
+## Why ?
+
+No-Code tools like Klaro Cards generally require an expression language for user
+to manipulate data easily. This language must be :
+
+- simple, because No-Code tools are used by non-tech people
+- portable, because they are implemented in various frontend/backend/db technologies
+- safe, because end-users writing code yield serious security issues
+- well-designed, because there are too many ill-designed programming languages already
+
+See also the Related work section below.
+
+## Current Features
+
+- **Arithmetic expressions** with scalars and variables
+- **Boolean expressions** with comparison and logical operators
+- **Temporal types** with dates, datetimes, and ISO8601 durations
+- **Infix notation** (standard mathematical notation)
+- **Arithmetic operators**: `+`, `-`, `*`, `/`, `%`, `^` (power, plus string repeat and array concat)
+- **Comparison operators**: `<`, `>`, `<=`, `>=`, `==`, `!=`
+- **Logical operators**: `&&`, `||`, `!`
+- **Unary operators**: `-`, `+`, `!`
+- **Pipe operator**: `|>` for function chaining (Elixir-style), parentheses optional
+- **Alternative operator**: `|` for fallback chains (returns first defined value)
+- **Type selectors**: `Int()`, `Float()`, `Bool()`, `Date()`, `Datetime()`, `Duration()`, `Data()` for parsing strings to typed values
+- **Type definitions**: Finitio-like schema validation with `let Person = { name: String, age: Int } in data |> Person`
+- **Lambdas**: `fn(x ~> x * 2)` or `x ~> x * 2` (sugar) for anonymous functions
+- **Input variable**: `_` for accessing external data passed to expressions
+- **Array iteration**: `map`, `filter`, `reduce`, `any`, `all` (JS/Ruby only)
+- **List functions**: `reverse`, `join(list, separator)`, `split(string, separator)`
+- **Literals**:
+  - Numbers: `42`, `3.14`
+  - Booleans: `true`, `false`
+  - Strings: `'hello'`
+  - Null: `null`
+  - Dates: `D2024-01-15`
+  - DateTimes: `D2024-01-15T10:30:00Z`
+  - Durations: `P1D`, `PT1H30M`, `P1Y2M3D` (ISO8601)
+  - Objects: `{name: 'Alice', age: 30}`
+  - Arrays: `[1, 2, 3]`, `['a', 'b']`, `[1, 'mixed', true, null]`
+  - DataPaths: `.x.y.z`, `.items.0.name` (for navigating data structures)
+- **Data functions**: `fetch(data, .path)` for safe access with null handling, `patch(data, .path, value)` for immutable updates, `merge(a, b)` and `deepMerge(a, b)` for merging objects
+- **Parentheses** for grouping
+- **Multi-target compilation**:
+  - Ruby (using `**` for power, `&&`/`||`/`!` for boolean logic, `Date.parse()`, `DateTime.parse()`, `ActiveSupport::Duration.parse()`)
+  - JavaScript (using `Math.pow()` for power, `&&`/`||`/`!` for boolean logic, `new Date()`, `Duration.parse()`)
+  - PostgreSQL (using `POWER()` for power, `AND`/`OR`/`NOT` for boolean logic, `DATE`, `TIMESTAMP`, `INTERVAL` for temporals)
+
+## Installation
+
+```bash
+npm install
+npm run build
+```
+
+## Testing
+
+Elo uses a comprehensive test suite that verifies:
+- **Unit tests**: Parser, AST, and compiler components
+- **Integration tests**: End-to-end compilation output
+- **Acceptance tests**: Compiled code execution in real runtimes (Ruby, Node.js, PostgreSQL)
+
+```bash
+npm run test:unit
+npm run test:integration
+npm run test:acceptance
+```
+
+## Command Line Interface
+
+Elo provides two CLI tools:
+- `eloc` - The compiler (for developers integrating Elo into their products)
+- `elo` - The evaluator (for quickly running Elo expressions)
+
+### Compiler (eloc)
+
+The compiler translates Elo expressions to Ruby, JavaScript, or SQL:
+
+```bash
+# Compile expression to JavaScript (default)
+./bin/eloc -e "2 + 3 * 4"
+
+# Compile expression to Ruby
+./bin/eloc -e "2 + 3 * 4" -t ruby
+
+# Compile expression to SQL
+./bin/eloc -e "2 + 3 * 4" -t sql
+
+# Compile with prelude (includes required runtime libraries)
+./bin/eloc -e "NOW + PT2H" -t ruby -p
+
+# Output only the prelude (useful for bundling)
+./bin/eloc --prelude-only -t js
+
+# Compile from file (each line is compiled separately)
+./bin/eloc input.elo -t ruby
+
+# Compile to file
+./bin/eloc -e "2 + 3" -t ruby -f output.rb
+
+# Compile from stdin
+echo "2 + 3 * 4" | ./bin/eloc -
+cat input.elo | ./bin/eloc - -t ruby
+```
+
+Options:
+- `-e, --expression <expr>` - Expression to compile
+- `-t, --target <lang>` - Target language: `ruby`, `js` (default), `sql`
+- `-p, --prelude` - Include necessary library imports/requires
+- `--prelude-only` - Output only the prelude (no expression needed)
+- `-f, --file <path>` - Output to file instead of stdout
+- `-h, --help` - Show help message
+
+### Evaluator (elo)
+
+The evaluator compiles to JavaScript and immediately evaluates the expression:
+
+```bash
+# Evaluate a simple expression
+./bin/elo -e "2 + 3 * 4"
+# Outputs: 14
+
+# Evaluate with input data
+./bin/elo -e "_.x + _.y" -d '{"x": 1, "y": 2}'
+# Outputs: 3
+
+# Evaluate with data from file
+./bin/elo -e "_.name" -d @data.json
+
+# Evaluate from .elo file
+./bin/elo expressions.elo
+
+# Pipe data through stdin
+echo '{"x": 10}' | ./bin/elo -e "_.x * 2" --stdin
+# Outputs: 20
+```
+
+Options:
+- `-e, --expression <expr>` - Expression to evaluate
+- `-d, --data <json>` - JSON input data for `_` variable (or `@file` to read from file)
+- `--stdin` - Read input data as JSON from stdin
+- `-h, --help` - Show help message
+
+## Using Elo in JavaScript/TypeScript
+
+The simplest way to use Elo is with the `compile()` function, which creates a callable JavaScript function from an Elo lambda expression:
+
+```typescript
+import { compile } from '@enspirit/elo';
+import { DateTime, Duration } from 'luxon';
+
+// Compile a lambda to a callable function
+const double = compile<(x: number) => number>(
+  'fn(x ~> x * 2)',
+  { runtime: { DateTime, Duration } }
+);
+double(21); // => 42
+
+// Temporal expressions work too
+const inThisWeek = compile<(d: unknown) => boolean>(
+  'fn(d ~> d in SOW ... EOW)',
+  { runtime: { DateTime, Duration } }
+);
+inThisWeek(DateTime.now()); // => true or false
+```
+
+The `runtime` option injects dependencies (like `DateTime` and `Duration` from luxon) into the compiled function. This avoids global variables and keeps the compiled code portable.
+
+## Lower-Level API
+
+For more control, you can use the lower-level parsing and compilation functions:
+
+```typescript
+import { parse, compileToRuby, compileToJavaScript, compileToSQL } from '@enspirit/elo';
+
+// Parse an expression
+const ast = parse(`
+  let
+    x = TODAY,
+    y = 3
+  in
+    assert(x + y * P1D == TODAY + P3D)
+`);
+
+// Compile to different targets
+console.log(compileToRuby(ast));
+console.log(compileToJavaScript(ast));
+console.log(compileToSQL(ast));
+```
+
+## Programmatic AST Construction
+
+```typescript
+import { binary, variable, literal } from './src';
+
+// Build: (price * quantity) - discount
+const ast = binary(
+  '-',
+  binary('*', variable('price'), variable('quantity')),
+  variable('discount')
+);
+```
+
+## Examples
+
+Run the examples:
+
+```bash
+npm run build
+node dist/examples/basic.js     # Arithmetic expressions
+node dist/examples/boolean.js   # Boolean expressions
+node dist/examples/temporal.js  # Temporal expressions (dates, durations)
+node dist/examples/demo.js      # Quick demo
+```
+
+## Project Structure
+
+```
+elo/
+├── src/              # Compiler source code
+│   ├── parser.ts     # Lexer and parser
+│   ├── ast.ts        # AST definitions
+│   ├── types.ts      # Type system
+│   ├── ir.ts         # Intermediate representation
+│   ├── transform.ts  # AST → IR transformation with type inference
+│   ├── stdlib.ts     # Standard library abstraction
+│   ├── compilers/    # Code generators (Ruby, JavaScript, SQL)
+│   └── preludes/     # Runtime support libraries
+├── test/             # Test suite
+│   ├── fixtures/     # Test cases
+│   ├── unit/         # Component tests
+│   ├── integration/  # Compilation tests
+│   └── acceptance/   # Runtime execution tests
+├── examples/         # Usage examples
+├── bin/eloc          # Compiler CLI
+├── bin/elo           # Evaluator CLI
+└── CLAUDE.md         # Developer guide
+```
+
+For detailed architecture documentation, see [CLAUDE.md](CLAUDE.md).
+
+## Related work
+
+Enspirit's previous research work includes a lot of places where such expressions
+are used, calling for a shared solution for the future.
+
+In many cases, observe that we require compiling expressions that amount to a
+single function evaluating on a context object, sometimes a scalar (Finitio),
+sometimes a current Tuple (Bmg), sometimes json data received from an API
+(Webspicy), or a current Card (Klaro Cards, similar to Bmg's Tuple).
+
+See https://elo-lang.org for more documentation.
+
+### Finitio
+
+The Finitio data validation language supports subtypes by constraints such as:
+
+```finitio
+PositiveInt = Int( i | i > 0 )
+```
+
+Currently, the constraint expression is written in the host language (js or ruby)
+and would require a portable expression language to go further.
+
+See https://finitio.io, https://github.com/enspirit/finitio-rb, https://github.com/enspirit/finitio.js
+
+### Bmg
+
+The Bmg relational algebra requires expressions for the `restrict` and `extend`
+operators inspired by **Tutorial D**. We currently rely on ruby code in some cases,
+but that prevents compiling relational expressions to SQL :
+
+```ruby
+r.restrict(->(t){ t[:budget] >= 120 })
+r.extend(:upcased => ->(t) { t[:name].upcase })
+```
+
+See https://www.relational-algebra.dev/, https://github.com/enspirit/bmg
+
+### Webspicy
+
+The Webspicy test framework requires a better expression language for data assertions.
+We currently rely on an hardcoded expression language that is very limited:
+
+```
+assert:
+- isEmpty
+- size(10)
+```
+
+See https://github.com/enspirit/webspicy
+
+### Klaro Cards
+
+The Klaro Cards No-Code tool uses various data expressions here and there :
+
+- Date ranges for Date/time dimensions : `SOW ... SOW+P1W`
+- Computed dimensions : `_.budget * 1.21`
+- Summary functions : `min(_.budget)`
+
+See https://klaro.cards
+
+## Contributing
+
+Elo follows a strict test-driven development methodology to ensure semantic equivalence across all three target languages (Ruby, JavaScript, SQL).
+
+**For developers and AI assistants**: See [CLAUDE.md](CLAUDE.md) for:
+- Test-driven development workflow
+- Three-stage test methodology (unit → integration → acceptance)
+- How to add new features and operators
+- Architecture documentation
+- Troubleshooting guide
+

package/bin/elo

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/src/elo.js');

package/bin/eloc

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/src/eloc.js');

package/dist/src/ast.d.ts

@@ -0,0 +1,309 @@
+/**
+ * AST node types for Elo expressions
+ */
+export type Expr = Literal | NullLiteral | StringLiteral | Variable | BinaryOp | UnaryOp | DateLiteral | DateTimeLiteral | DurationLiteral | TemporalKeyword | FunctionCall | MemberAccess | LetExpr | IfExpr | Lambda | ObjectLiteral | ArrayLiteral | Alternative | Apply | DataPath | TypeDef;
+/**
+ * Literal value (number or boolean)
+ */
+export interface Literal {
+    type: 'literal';
+    value: number | boolean;
+}
+/**
+ * Null literal
+ */
+export interface NullLiteral {
+    type: 'null';
+}
+/**
+ * String literal (single-quoted)
+ */
+export interface StringLiteral {
+    type: 'string';
+    value: string;
+}
+/**
+ * Date literal (ISO8601 date string)
+ */
+export interface DateLiteral {
+    type: 'date';
+    value: string;
+}
+/**
+ * DateTime literal (ISO8601 datetime string)
+ */
+export interface DateTimeLiteral {
+    type: 'datetime';
+    value: string;
+}
+/**
+ * Duration literal (ISO8601 duration)
+ */
+export interface DurationLiteral {
+    type: 'duration';
+    value: string;
+}
+/**
+ * Temporal keyword (NOW, TODAY, TOMORROW, YESTERDAY, and period boundaries)
+ */
+export interface TemporalKeyword {
+    type: 'temporal_keyword';
+    keyword: 'NOW' | 'TODAY' | 'TOMORROW' | 'YESTERDAY' | 'SOD' | 'EOD' | 'SOW' | 'EOW' | 'SOM' | 'EOM' | 'SOQ' | 'EOQ' | 'SOY' | 'EOY' | 'BOT' | 'EOT';
+}
+/**
+ * Variable reference
+ */
+export interface Variable {
+    type: 'variable';
+    name: string;
+}
+/**
+ * Binary operation
+ */
+export interface BinaryOp {
+    type: 'binary';
+    operator: '+' | '-' | '*' | '/' | '%' | '^' | '<' | '>' | '<=' | '>=' | '==' | '!=' | '&&' | '||';
+    left: Expr;
+    right: Expr;
+}
+/**
+ * Unary operation
+ */
+export interface UnaryOp {
+    type: 'unary';
+    operator: '-' | '+' | '!';
+    operand: Expr;
+}
+/**
+ * Function call
+ */
+export interface FunctionCall {
+    type: 'function_call';
+    name: string;
+    args: Expr[];
+}
+/**
+ * Function application (calling an expression that evaluates to a function)
+ */
+export interface Apply {
+    type: 'apply';
+    fn: Expr;
+    args: Expr[];
+}
+/**
+ * Member access (dot notation)
+ */
+export interface MemberAccess {
+    type: 'member_access';
+    object: Expr;
+    property: string;
+}
+/**
+ * Variable binding in a let expression
+ */
+export interface LetBinding {
+    name: string;
+    value: Expr;
+}
+/**
+ * Let expression: let x = 1, y = 2 in body
+ */
+export interface LetExpr {
+    type: 'let';
+    bindings: LetBinding[];
+    body: Expr;
+}
+/**
+ * If expression: if condition then consequent else alternative
+ */
+export interface IfExpr {
+    type: 'if';
+    condition: Expr;
+    then: Expr;
+    else: Expr;
+}
+/**
+ * Lambda expression: fn( params ~> body )
+ */
+export interface Lambda {
+    type: 'lambda';
+    params: string[];
+    body: Expr;
+}
+/**
+ * Helper functions to create AST nodes
+ */
+export declare function literal(value: number | boolean): Literal;
+export declare function nullLiteral(): NullLiteral;
+export declare function stringLiteral(value: string): StringLiteral;
+export declare function dateLiteral(value: string): DateLiteral;
+export declare function dateTimeLiteral(value: string): DateTimeLiteral;
+export declare function durationLiteral(value: string): DurationLiteral;
+export declare function variable(name: string): Variable;
+export declare function binary(operator: BinaryOp['operator'], left: Expr, right: Expr): BinaryOp;
+export declare function unary(operator: UnaryOp['operator'], operand: Expr): UnaryOp;
+export declare function temporalKeyword(keyword: TemporalKeyword['keyword']): TemporalKeyword;
+export declare function functionCall(name: string, args: Expr[]): FunctionCall;
+export declare function apply(fn: Expr, args: Expr[]): Apply;
+export declare function memberAccess(object: Expr, property: string): MemberAccess;
+/**
+ * Creates a let expression, desugaring multiple bindings into nested let expressions.
+ * `let a = 1, b = 2 in body` becomes `let a = 1 in let b = 2 in body`
+ * This ensures that later bindings can reference earlier ones.
+ */
+export declare function letExpr(bindings: LetBinding[], body: Expr): LetExpr;
+/**
+ * Creates an if expression: if condition then consequent else alternative
+ */
+export declare function ifExpr(condition: Expr, thenBranch: Expr, elseBranch: Expr): IfExpr;
+/**
+ * Creates a lambda expression: fn( params ~> body )
+ */
+export declare function lambda(params: string[], body: Expr): Lambda;
+/**
+ * Object property (key-value pair)
+ */
+export interface ObjectProperty {
+    key: string;
+    value: Expr;
+}
+/**
+ * Object literal: {key: value, ...}
+ */
+export interface ObjectLiteral {
+    type: 'object';
+    properties: ObjectProperty[];
+}
+/**
+ * Creates an object literal: {key: value, ...}
+ */
+export declare function objectLiteral(properties: ObjectProperty[]): ObjectLiteral;
+/**
+ * Array literal: [expr, expr, ...]
+ */
+export interface ArrayLiteral {
+    type: 'array';
+    elements: Expr[];
+}
+/**
+ * Creates an array literal: [expr, expr, ...]
+ */
+export declare function arrayLiteral(elements: Expr[]): ArrayLiteral;
+/**
+ * Alternative expression: a | b | c
+ * Evaluates alternatives left-to-right, returns first non-null value.
+ */
+export interface Alternative {
+    type: 'alternative';
+    alternatives: Expr[];
+}
+/**
+ * Creates an alternative expression: a | b | c
+ */
+export declare function alternative(alternatives: Expr[]): Alternative;
+/**
+ * DataPath literal: .x.y.z or .items.0.name
+ * A path for navigating data structures, inspired by JSONPath.
+ * Segments can be property names (strings) or array indices (numbers).
+ */
+export interface DataPath {
+    type: 'datapath';
+    segments: (string | number)[];
+}
+/**
+ * Creates a datapath literal: .x.y.z
+ */
+export declare function dataPath(segments: (string | number)[]): DataPath;
+/**
+ * Type expression for type definitions
+ * Used in `let Person = { name: String, age: Int }` style declarations
+ */
+export type TypeExpr = TypeRef | TypeSchema | SubtypeConstraint | ArrayType | UnionType;
+/**
+ * Reference to a base type: String, Int, Bool, Datetime, Any
+ */
+export interface TypeRef {
+    kind: 'type_ref';
+    name: string;
+}
+/**
+ * Object type schema: { name: String, age: Int }
+ * extras controls handling of extra attributes:
+ * - undefined/'closed': extra attributes are not allowed (default)
+ * - 'ignored': extra attributes are allowed but not included in output
+ * - TypeExpr: extra attributes are allowed and must match this type
+ */
+export interface TypeSchema {
+    kind: 'type_schema';
+    properties: TypeSchemaProperty[];
+    extras?: 'closed' | 'ignored' | TypeExpr;
+}
+/**
+ * Subtype constraint: Int(i | i > 0)
+ * A base type with a predicate constraint
+ */
+export interface SubtypeConstraint {
+    kind: 'subtype_constraint';
+    baseType: TypeExpr;
+    variable: string;
+    constraint: Expr;
+}
+/**
+ * Array type: [Int], [String], [{ name: String }]
+ */
+export interface ArrayType {
+    kind: 'array_type';
+    elementType: TypeExpr;
+}
+/**
+ * Union type: Int|String, String|Int|Bool
+ * Tries each type in order, returns first successful parse
+ */
+export interface UnionType {
+    kind: 'union_type';
+    types: TypeExpr[];
+}
+/**
+ * Property in a type schema
+ */
+export interface TypeSchemaProperty {
+    key: string;
+    typeExpr: TypeExpr;
+    optional?: boolean;
+}
+/**
+ * Type definition: let Person = { name: String, age: Int }
+ * Binds a type name (uppercase) to a type expression.
+ * The body can use the type via pipe: data |> Person
+ */
+export interface TypeDef {
+    type: 'typedef';
+    name: string;
+    typeExpr: TypeExpr;
+    body: Expr;
+}
+/**
+ * Creates a type reference: String, Int, etc.
+ */
+export declare function typeRef(name: string): TypeRef;
+/**
+ * Creates a type schema: { name: String, age: Int }
+ */
+export declare function typeSchema(properties: TypeSchemaProperty[], extras?: 'closed' | 'ignored' | TypeExpr): TypeSchema;
+/**
+ * Creates a type definition expression
+ */
+export declare function typeDef(name: string, typeExpr: TypeExpr, body: Expr): TypeDef;
+/**
+ * Creates a subtype constraint: Int(i | i > 0)
+ */
+export declare function subtypeConstraint(baseType: TypeExpr, variable: string, constraint: Expr): SubtypeConstraint;
+/**
+ * Creates an array type: [Int]
+ */
+export declare function arrayType(elementType: TypeExpr): ArrayType;
+/**
+ * Creates a union type: Int|String
+ */
+export declare function unionType(types: TypeExpr[]): UnionType;
+//# sourceMappingURL=ast.d.ts.map

package/dist/src/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/ast.ts"],"names":[],"mappings":"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"}