@ldclabs/kip-lang 0.2.1 → 0.3.0

package/dist/parser.js

@@ -49,14 +49,20 @@ class Parser {
                 return this.parseFindStatement();
             case TokenType.Upsert:
                 return this.parseUpsertStatement();
+            case TokenType.Update:
+                return this.parseUpdateStatement();
+            case TokenType.Merge:
+                return this.parseMergeStatement();
             case TokenType.Delete:
                 return this.parseDeleteStatement();
             case TokenType.Describe:
                 return this.parseDescribeStatement();
             case TokenType.Search:
                 return this.parseSearchStatement();
+            case TokenType.Export:
+                return this.parseExportStatement();
             default:
-                this.error(`Unexpected token '${tok.value}', expected a statement keyword (FIND, UPSERT, DELETE, DESCRIBE, SEARCH)`, tok);
+                this.error(`Unexpected token '${tok.value}', expected a statement keyword (FIND, UPSERT, UPDATE, MERGE, DELETE, DESCRIBE, SEARCH, EXPORT)`, tok);
                 this.advance();
                 return null;
         }
@@ -151,6 +157,10 @@ class Parser {
         const handle = this.expectVariable();
         this.expect(TokenType.LBrace);
         const matcher = this.parseConceptMatcher();
+        let expectVersion;
+        if (this.check(TokenType.Expect)) {
+            expectVersion = this.parseExpectVersion();
+        }
         let setAttributes;
         let setPropositions;
         let metadata;
@@ -197,6 +207,7 @@ class Parser {
             kind: 'ConceptBlock',
             handle,
             matcher,
+            expectVersion,
             setAttributes,
             setPropositions,
             metadata,
@@ -214,6 +225,10 @@ class Parser {
         }
         this.expect(TokenType.LBrace);
         const proposition = this.parsePropositionPatternBody(undefined);
+        let expectVersion;
+        if (this.check(TokenType.Expect)) {
+            expectVersion = this.parseExpectVersion();
+        }
         let setAttributes;
         let metadata;
         this.skipComments();
@@ -250,6 +265,7 @@ class Parser {
             subject: proposition.subject,
             predicate: proposition.predicate,
             object: proposition.object,
+            expectVersion,
             setAttributes,
             metadata,
             range: { start, end: this.currentPos() },
@@ -257,6 +273,74 @@ class Parser {
         };
     }
     // ────────────────────────────────────────────────────────────────────
+    //  UPDATE
+    // ────────────────────────────────────────────────────────────────────
+    parseUpdateStatement() {
+        const start = this.currentPos();
+        const comments = this.collectLeadingComments();
+        this.expect(TokenType.Update);
+        const target = this.expectVariable();
+        let setAttributes;
+        let setMetadata;
+        this.skipComments();
+        while (this.check(TokenType.Set) && !this.isAtEnd()) {
+            const setStart = this.currentPos();
+            this.advance();
+            if (this.check(TokenType.Attributes)) {
+                this.advance();
+                setAttributes = this.parseSetAttributesBody(setStart);
+            }
+            else if (this.check(TokenType.Metadata)) {
+                this.advance();
+                setMetadata = this.parseSetMetadataBody(setStart);
+            }
+            else {
+                this.error(`Expected ATTRIBUTES or METADATA after SET in UPDATE statement`, this.current());
+                this.advance();
+            }
+            this.skipComments();
+        }
+        if (!setAttributes && !setMetadata) {
+            this.error(`Expected SET ATTRIBUTES or SET METADATA in UPDATE statement`, this.current());
+        }
+        const where = this.parseWhereClause();
+        let limit;
+        if (this.check(TokenType.Limit)) {
+            limit = this.parseLimitClause();
+        }
+        return {
+            kind: 'UpdateStatement',
+            target,
+            setAttributes,
+            setMetadata,
+            where,
+            limit,
+            range: { start, end: this.currentPos() },
+            leadingComments: comments.length > 0 ? comments : undefined
+        };
+    }
+    // ────────────────────────────────────────────────────────────────────
+    //  MERGE
+    // ────────────────────────────────────────────────────────────────────
+    parseMergeStatement() {
+        const start = this.currentPos();
+        const comments = this.collectLeadingComments();
+        this.expect(TokenType.Merge);
+        this.expect(TokenType.Concept);
+        const source = this.expectVariable();
+        this.expect(TokenType.Into);
+        const target = this.expectVariable();
+        const where = this.parseWhereClause();
+        return {
+            kind: 'MergeStatement',
+            source,
+            target,
+            where,
+            range: { start, end: this.currentPos() },
+            leadingComments: comments.length > 0 ? comments : undefined
+        };
+    }
+    // ────────────────────────────────────────────────────────────────────
     //  DELETE
     // ────────────────────────────────────────────────────────────────────
     parseDeleteStatement() {
@@ -338,6 +422,7 @@ class Parser {
         this.expect(TokenType.Describe);
         let describeType;
         let typeName;
+        let typeNameValue;
         let limit;
         let cursor;
         if (this.check(TokenType.Primer)) {
@@ -357,7 +442,11 @@ class Parser {
             else if (this.check(TokenType.Type)) {
                 describeType = 'CONCEPT_TYPE';
                 this.advance();
-                typeName = this.expectStringValue();
+                typeNameValue = this.parseStringOrParameterValue('DESCRIBE CONCEPT TYPE');
+                typeName =
+                    typeNameValue.kind === 'StringLiteral'
+                        ? typeNameValue.parsed
+                        : typeNameValue.name;
             }
             else {
                 this.error(`Expected TYPE or TYPES after DESCRIBE CONCEPT`, this.current());
@@ -373,7 +462,11 @@ class Parser {
             else if (this.check(TokenType.Type)) {
                 describeType = 'PROPOSITION_TYPE';
                 this.advance();
-                typeName = this.expectStringValue();
+                typeNameValue = this.parseStringOrParameterValue('DESCRIBE PROPOSITION TYPE');
+                typeName =
+                    typeNameValue.kind === 'StringLiteral'
+                        ? typeNameValue.parsed
+                        : typeNameValue.name;
             }
             else {
                 this.error(`Expected TYPE or TYPES after DESCRIBE PROPOSITION`, this.current());
@@ -394,6 +487,7 @@ class Parser {
             kind: 'DescribeStatement',
             describeType,
             typeName,
+            typeNameValue,
             limit,
             cursor,
             range: { start, end: this.currentPos() },
@@ -424,18 +518,35 @@ class Parser {
         const term = termValue.kind === 'StringLiteral' ? termValue.parsed : termValue.name;
         let withType;
         let withTypeValue;
-        if (this.check(TokenType.With)) {
-            this.advance();
-            this.expect(TokenType.Type);
-            withTypeValue = this.parseStringOrParameterValue('SEARCH WITH TYPE');
-            withType =
-                withTypeValue.kind === 'StringLiteral'
-                    ? withTypeValue.parsed
-                    : withTypeValue.name;
-        }
+        let mode;
+        let modeValue;
+        let threshold;
         let limit;
-        if (this.check(TokenType.Limit)) {
-            limit = this.parseLimitClause();
+        while (!this.isAtEnd()) {
+            if (this.check(TokenType.With)) {
+                this.advance();
+                this.expect(TokenType.Type);
+                withTypeValue = this.parseStringOrParameterValue('SEARCH WITH TYPE');
+                withType =
+                    withTypeValue.kind === 'StringLiteral'
+                        ? withTypeValue.parsed
+                        : withTypeValue.name;
+            }
+            else if (this.check(TokenType.Mode)) {
+                this.advance();
+                modeValue = this.parseStringOrParameterValue('SEARCH MODE');
+                mode =
+                    modeValue.kind === 'StringLiteral' ? modeValue.parsed : modeValue.name;
+            }
+            else if (this.check(TokenType.Threshold)) {
+                threshold = this.parseThresholdClause();
+            }
+            else if (this.check(TokenType.Limit)) {
+                limit = this.parseLimitClause();
+            }
+            else {
+                break;
+            }
         }
         return {
             kind: 'SearchStatement',
@@ -444,6 +555,31 @@ class Parser {
             termValue,
             withType,
             withTypeValue,
+            mode,
+            modeValue,
+            threshold,
+            limit,
+            range: { start, end: this.currentPos() },
+            leadingComments: comments.length > 0 ? comments : undefined
+        };
+    }
+    // ────────────────────────────────────────────────────────────────────
+    //  EXPORT
+    // ────────────────────────────────────────────────────────────────────
+    parseExportStatement() {
+        const start = this.currentPos();
+        const comments = this.collectLeadingComments();
+        this.expect(TokenType.Export);
+        const target = this.expectVariable();
+        const where = this.parseWhereClause();
+        let limit;
+        if (this.check(TokenType.Limit)) {
+            limit = this.parseLimitClause();
+        }
+        return {
+            kind: 'ExportStatement',
+            target,
+            where,
             limit,
             range: { start, end: this.currentPos() },
             leadingComments: comments.length > 0 ? comments : undefined
@@ -617,6 +753,31 @@ class Parser {
     }
     parsePredicateExpr() {
         const start = this.currentPos();
+        if (this.check(TokenType.Variable)) {
+            const pred = this.parsePredicateVariable();
+            if (this.check(TokenType.LBrace)) {
+                this.error(`Predicate variables cannot use hop ranges; use a quoted predicate literal for path traversal`, this.current());
+                this.parseHopRange();
+            }
+            if (this.check(TokenType.Pipe)) {
+                this.error(`Predicate variables cannot be used in predicate alternations`, this.current());
+                while (this.match(TokenType.Pipe)) {
+                    if (this.check(TokenType.String)) {
+                        this.parsePredicateLiteral();
+                    }
+                    else if (this.check(TokenType.Variable)) {
+                        this.parsePredicateVariable();
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            return {
+                ...pred,
+                range: { start, end: this.currentPos() }
+            };
+        }
         const first = this.parsePredicateLiteral();
         // Check for alternation: "pred1" | "pred2"
         if (this.check(TokenType.Pipe)) {
@@ -632,6 +793,15 @@ class Parser {
         }
         return first;
     }
+    parsePredicateVariable() {
+        const start = this.currentPos();
+        const name = this.expectVariable();
+        return {
+            kind: 'PredicateVariable',
+            name,
+            range: { start, end: this.currentPos() }
+        };
+    }
     parsePredicateLiteral() {
         const start = this.currentPos();
         const value = this.expectStringValue();
@@ -736,6 +906,16 @@ class Parser {
             range: { start, end: this.currentPos() }
         };
     }
+    parseSetMetadataBody(start) {
+        this.expect(TokenType.LBrace);
+        const entries = this.parseObjectEntries();
+        this.expect(TokenType.RBrace);
+        return {
+            kind: 'SetMetadata',
+            entries,
+            range: { start, end: this.currentPos() }
+        };
+    }
     parseSetPropositionsBody(start) {
         this.expect(TokenType.LBrace);
         const items = [];
@@ -831,6 +1011,17 @@ class Parser {
             range: { start, end: this.currentPos() }
         };
     }
+    parseExpectVersion() {
+        const start = this.currentPos();
+        this.expect(TokenType.Expect);
+        this.expect(TokenType.Version);
+        const value = this.parseNumberOrParameterValue('EXPECT VERSION');
+        return {
+            kind: 'ExpectVersion',
+            value,
+            range: { start, end: this.currentPos() }
+        };
+    }
     // ────────────────────────────────────────────────────────────────────
     //  ORDER BY, LIMIT, CURSOR
     // ────────────────────────────────────────────────────────────────────
@@ -838,6 +1029,22 @@ class Parser {
         const start = this.currentPos();
         this.expect(TokenType.Order);
         this.expect(TokenType.By);
+        const keys = [];
+        keys.push(this.parseOrderByKey());
+        while (this.match(TokenType.Comma)) {
+            keys.push(this.parseOrderByKey());
+        }
+        const first = keys[0];
+        return {
+            kind: 'OrderByClause',
+            keys,
+            expression: first.expression,
+            direction: first.direction,
+            range: { start, end: this.currentPos() }
+        };
+    }
+    parseOrderByKey() {
+        const start = this.currentPos();
         const expression = this.parseExpression();
         let direction = 'ASC';
         if (this.check(TokenType.Asc)) {
@@ -849,45 +1056,59 @@ class Parser {
             direction = 'DESC';
         }
         return {
-            kind: 'OrderByClause',
+            kind: 'OrderByKey',
             expression,
             direction,
             range: { start, end: this.currentPos() }
         };
     }
-    parseLimitClause() {
+    parseThresholdClause() {
         const start = this.currentPos();
-        this.expect(TokenType.Limit);
+        this.expect(TokenType.Threshold);
+        const value = this.parseNumberOrParameterValue('THRESHOLD');
+        return {
+            kind: 'ThresholdClause',
+            value,
+            range: { start, end: this.currentPos() }
+        };
+    }
+    parseNumberOrParameterValue(context) {
         const tok = this.current();
+        const start = this.currentPos();
         let value;
         if (tok.type === TokenType.Number) {
             value = {
                 kind: 'NumberLiteral',
                 value: Number(tok.value),
                 raw: tok.value,
-                range: { start: this.currentPos(), end: this.currentPos() }
+                range: { start, end: start }
             };
             this.advance();
             value.range.end = this.currentPos();
+            return value;
         }
-        else if (tok.type === TokenType.Parameter) {
+        if (tok.type === TokenType.Parameter) {
             value = {
                 kind: 'ParameterRef',
                 name: tok.value,
-                range: { start: this.currentPos(), end: this.currentPos() }
+                range: { start, end: start }
             };
             this.advance();
             value.range.end = this.currentPos();
+            return value;
         }
-        else {
-            this.error(`Expected number or parameter after LIMIT`, tok);
-            value = {
-                kind: 'NumberLiteral',
-                value: 0,
-                raw: '0',
-                range: { start: this.currentPos(), end: this.currentPos() }
-            };
-        }
+        this.error(`Expected number or parameter after ${context}`, tok);
+        return {
+            kind: 'NumberLiteral',
+            value: 0,
+            raw: '0',
+            range: { start, end: start }
+        };
+    }
+    parseLimitClause() {
+        const start = this.currentPos();
+        this.expect(TokenType.Limit);
+        const value = this.parseNumberOrParameterValue('LIMIT');
         return {
             kind: 'LimitClause',
             value,
@@ -1215,9 +1436,14 @@ class Parser {
                 value,
                 range: { start: entryStart, end: this.currentPos() }
             });
-            // Optional comma
-            this.match(TokenType.Comma);
             this.skipComments();
+            if (this.check(TokenType.RBrace))
+                break;
+            if (this.match(TokenType.Comma)) {
+                this.skipComments();
+                continue;
+            }
+            this.error(`Expected ',' or '}' after object entry`, this.current());
         }
         return entries;
     }
@@ -1351,7 +1577,11 @@ class Parser {
             type === TokenType.Regex ||
             type === TokenType.In ||
             type === TokenType.IsNull ||
-            type === TokenType.IsNotNull);
+            type === TokenType.IsNotNull ||
+            type === TokenType.Add ||
+            type === TokenType.Mul ||
+            type === TokenType.Clamp ||
+            type === TokenType.Coalesce);
     }
     /** Keywords that can also serve as property names in dot notation or object keys */
     isNonAmbiguousKeyword(type) {
@@ -1370,7 +1600,12 @@ class Parser {
             type === TokenType.By ||
             type === TokenType.Order ||
             type === TokenType.Set ||
-            type === TokenType.With);
+            type === TokenType.With ||
+            type === TokenType.Into ||
+            type === TokenType.Expect ||
+            type === TokenType.Version ||
+            type === TokenType.Mode ||
+            type === TokenType.Threshold);
     }
     unescapeString(raw) {
         if (raw.startsWith('"') && raw.endsWith('"')) {
@@ -1415,9 +1650,12 @@ class Parser {
         const stmtStarters = new Set([
             TokenType.Find,
             TokenType.Upsert,
+            TokenType.Update,
+            TokenType.Merge,
             TokenType.Delete,
             TokenType.Describe,
             TokenType.Search,
+            TokenType.Export,
             TokenType.EOF
         ]);
         while (!this.isAtEnd() && !stmtStarters.has(this.current().type)) {