naidejs 1.1.0 → 1.3.0

package/src/parser.js

@@ -14,14 +14,11 @@ export class Parser {
   }
 
   preprocessTokens(tokens) {
-    // Remove INDENT/DEDENT pairs around pipe continuation lines
-    // Pattern: NEWLINE INDENT PIPE -> NEWLINE PIPE (and remove matching DEDENT)
     const result = [...tokens];
     const indentsToRemove = new Set();
 
     for (let i = 0; i < result.length; i++) {
       if (result[i].type !== T.INDENT) continue;
-      // Look forward past any newlines for PIPE
       let j = i + 1;
       while (j < result.length && result[j].type === T.NEWLINE) j++;
       if (j < result.length && result[j].type === T.PIPE) {
@@ -31,7 +28,6 @@ export class Parser {
 
     if (indentsToRemove.size === 0) return result;
 
-    // For each INDENT to remove, find matching DEDENT
     const dedentsToRemove = new Set();
     for (const idx of indentsToRemove) {
       let depth = 0;
@@ -65,7 +61,16 @@ export class Parser {
   expect(type) {
     const tok = this.advance();
     if (tok.type !== type) {
-      throw this.error(`Expected ${type} but got ${tok.type} ('${tok.value}')`, tok);
+      const hints = {
+        COLON: "Missing ':' — blocks (if, fn, server, etc.) need a colon at the end",
+        INDENT: "Expected an indented block — check your indentation (use 2 spaces)",
+        RPAREN: "Missing closing ')'",
+        RBRACKET: "Missing closing ']'",
+        RBRACE: "Missing closing '}'",
+        IDENT: "Expected an identifier (variable/function name)",
+      };
+      const hint = hints[type] ? `\n  Hint: ${hints[type]}` : '';
+      throw this.error(`Expected ${type} but got ${tok.type} ('${tok.value}')${hint}`, tok);
     }
     return tok;
   }
@@ -85,16 +90,24 @@ export class Parser {
     return types.includes(this.peek().type);
   }
 
+  isIdentLike(type) {
+    return type === T.IDENT || TYPE_TOKENS.has(type) ||
+      type === T.LOG || type === T.DB || type === T.GET ||
+      type === T.POST || type === T.PUT || type === T.DEL ||
+      type === T.MATCH || type === T.ON || type === T.NEW ||
+      type === T.FROM || type === T.AS || type === T.SELF ||
+      type === T.SCHEMA || type === T.CRUD || type === T.AUTH ||
+      type === T.CORS || type === T.LIMIT || type === T.ENV ||
+      type === T.EVERY || type === T.WATCH || type === T.STATIC ||
+      type === T.WS || type === T.GROUP || type === T.COOKIE ||
+      type === T.NOT || type === T.AND || type === T.OR ||
+      type === T.IN || type === T.BREAK || type === T.CONTINUE ||
+      type === T.THROW || type === T.MUT || type === T.PUB;
+  }
+
   expectPropertyName() {
     const tok = this.advance();
-    if (tok.type === T.IDENT || TYPE_TOKENS.has(tok.type) ||
-        tok.type === T.LOG || tok.type === T.DB || tok.type === T.GET ||
-        tok.type === T.POST || tok.type === T.PUT || tok.type === T.DEL ||
-        tok.type === T.MATCH || tok.type === T.ON || tok.type === T.NEW ||
-        tok.type === T.FROM || tok.type === T.AS || tok.type === T.SELF ||
-        tok.type === T.SCHEMA || tok.type === T.CRUD || tok.type === T.AUTH ||
-        tok.type === T.CORS || tok.type === T.LIMIT || tok.type === T.ENV ||
-        tok.type === T.EVERY || tok.type === T.WATCH) {
+    if (this.isIdentLike(tok.type)) {
       return tok.value;
     }
     throw this.error(`Expected property name but got ${tok.type} ('${tok.value}')`, tok);
@@ -148,7 +161,9 @@ export class Parser {
       case T.BREAK: this.advance(); return new ASTNode('Break');
       case T.CONTINUE: this.advance(); return new ASTNode('Continue');
       case T.MUT: return this.parseMutVariable();
-      case T.DB: return this.parseDbStatement();
+      case T.DB:
+        if (this.peek(1).type === T.DOT) return this.parseDbStatement();
+        return this.parseDbDir();
       case T.AWAIT: return this.parseAwaitStatement();
       case T.AWAIT_ALL: return this.parseAwaitAll();
       case T.SCHEMA: return this.parseSchema();
@@ -173,6 +188,19 @@ export class Parser {
       case T.WATCH:
         if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
         return this.parseWatch();
+      case T.STATIC:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseStatic();
+      case T.WS:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseWs();
+      case T.GROUP:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseGroup();
+      case T.COOKIE:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        this.advance();
+        return new ASTNode('CookieDecl');
       default:
         if (TYPE_TOKENS.has(tok.type)) {
           return this.parseTypedVariable();
@@ -181,14 +209,10 @@ export class Parser {
     }
   }
 
-  // use express
-  // use express from "express"
-  // use {readFile, writeFile} from "fs/promises"
   parseUse() {
     this.advance(); // use
 
     if (this.at(T.LBRACE)) {
-      // use {a, b} from "module"
       this.advance();
       const names = [];
       while (!this.at(T.RBRACE) && !this.at(T.EOF)) {
@@ -226,8 +250,6 @@ export class Parser {
     return tok.value;
   }
 
-  // fn name(params) -> returnType:
-  //   body
   parseFunction(isAsync, isPublic) {
     this.advance(); // fn or fn.async
     const name = this.expect(T.IDENT).value;
@@ -300,7 +322,6 @@ export class Parser {
     if (this.at(T.FN_ASYNC)) return this.parseFunction(true, true);
     if (this.at(T.MODEL)) return this.parseModel(true);
 
-    // pub variable
     if (TYPE_TOKENS.has(this.peek().type)) {
       const node = this.parseTypedVariable();
       node.isPublic = true;
@@ -310,24 +331,25 @@ export class Parser {
     throw this.error('Expected fn, model, or type after pub');
   }
 
-  // ret expression
   parseReturn() {
     this.advance(); // ret
     if (this.at(T.NEWLINE) || this.at(T.EOF) || this.at(T.DEDENT)) {
       return new ASTNode('Return', { value: null });
     }
-    // ret.status 200 {...}
     if (this.match(T.DOT)) {
       const method = this.expect(T.IDENT).value;
-      const statusCode = this.parseExpression();
-      const body = this.parseExpression();
-      return new ASTNode('ReturnStatus', { method, statusCode, body });
+      if (method === 'status') {
+        const statusCode = this.parseExpression();
+        const body = this.parseExpression();
+        return new ASTNode('ReturnStatus', { method, statusCode, body });
+      }
+      const value = this.parseExpression();
+      return new ASTNode('ReturnMethod', { method, value });
     }
     const value = this.parseExpression();
     return new ASTNode('Return', { value });
   }
 
-  // str name = "hello"
   parseTypedVariable() {
     const varType = this.advance().value;
     const name = this.expect(T.IDENT).value;
@@ -336,7 +358,6 @@ export class Parser {
     return new ASTNode('TypedVar', { varType, name, value, isMut: false, isPublic: false });
   }
 
-  // mut int counter = 0
   parseMutVariable() {
     this.advance(); // mut
     if (TYPE_TOKENS.has(this.peek().type)) {
@@ -344,19 +365,12 @@ export class Parser {
       node.isMut = true;
       return node;
     }
-    // mut name = value (no type)
     const name = this.expect(T.IDENT).value;
     this.expect(T.ASSIGN);
     const value = this.parseExpression();
     return new ASTNode('TypedVar', { varType: null, name, value, isMut: true });
   }
 
-  // if condition:
-  //   body
-  // elif condition:
-  //   body
-  // else:
-  //   body
   parseIf() {
     this.advance(); // if
     const condition = this.parseExpression();
@@ -384,15 +398,12 @@ export class Parser {
     return new ASTNode('If', { condition, body, elifs, elseBody });
   }
 
-  // each item in collection:
-  //   body
   parseEach() {
     this.advance(); // each
     let key = null;
     const valueName = this.expect(T.IDENT).value;
     if (this.match(T.COMMA)) {
       key = valueName;
-      // The next ident is actually the value
       const val = this.expect(T.IDENT).value;
       this.expect(T.IN);
       const collection = this.parseExpression();
@@ -407,8 +418,6 @@ export class Parser {
     return new ASTNode('Each', { key: null, value: valueName, collection, body });
   }
 
-  // for i in 0..10:
-  //   body
   parseFor() {
     this.advance(); // for
     const varName = this.expect(T.IDENT).value;
@@ -421,8 +430,6 @@ export class Parser {
     return new ASTNode('For', { varName, start, end, body });
   }
 
-  // while condition:
-  //   body
   parseWhile() {
     this.advance(); // while
     const condition = this.parseExpression();
@@ -431,9 +438,6 @@ export class Parser {
     return new ASTNode('While', { condition, body });
   }
 
-  // match value:
-  //   pattern: body
-  //   _: default
   parseMatch() {
     this.advance(); // match
     const value = this.parseExpression();
@@ -471,10 +475,6 @@ export class Parser {
     return new ASTNode('Match', { value, cases });
   }
 
-  // try:
-  //   body
-  // fail e:
-  //   handler
   parseTry() {
     this.advance(); // try
     this.expect(T.COLON);
@@ -495,14 +495,10 @@ export class Parser {
     return new ASTNode('Try', { body, catchVar, catchBody });
   }
 
-  // server app port 3000:
-  //   get "/path" -> type:
-  //     body
   parseServer() {
     this.advance(); // server
     const name = this.expect(T.IDENT).value;
 
-    let portKw = null;
     let port = null;
     if (this.at(T.IDENT) && this.peek().value === 'port') {
       this.advance();
@@ -530,6 +526,17 @@ export class Parser {
         routes.push(this.parseCors());
       } else if (this.at(T.LIMIT)) {
         routes.push(this.parseLimit());
+      } else if (this.at(T.STATIC)) {
+        routes.push(this.parseStatic());
+      } else if (this.at(T.WS)) {
+        routes.push(this.parseWs());
+      } else if (this.at(T.GROUP)) {
+        routes.push(this.parseGroup());
+      } else if (this.at(T.COOKIE)) {
+        this.advance();
+        routes.push(new ASTNode('CookieDecl'));
+      } else if (this.at(T.IDENT) && this.peek().value === 'error') {
+        routes.push(this.parseErrorHandler());
       } else {
         routes.push(this.parseStatement());
       }
@@ -579,11 +586,6 @@ export class Parser {
     return new ASTNode('Middleware', { name, params, body });
   }
 
-  // model User:
-  //   str name
-  //   int age
-  //   fn greet() -> str:
-  //     ret "hi"
   parseModel(isPublic = false) {
     this.advance(); // model
     const name = this.expect(T.IDENT).value;
@@ -615,7 +617,6 @@ export class Parser {
         }
         fields.push({ name: fieldName, type: fieldType, defaultValue });
       } else {
-        // skip unknown
         this.advance();
       }
       this.skipNewlines();
@@ -625,8 +626,6 @@ export class Parser {
     return new ASTNode('Model', { name, parent, fields, methods, isPublic });
   }
 
-  // on event:
-  //   body
   parseOn() {
     this.advance(); // on
     const event = this.parseExpression();
@@ -635,8 +634,6 @@ export class Parser {
     return new ASTNode('On', { event, body });
   }
 
-  // log "message"
-  // log.error "message"
   parseLog() {
     this.advance(); // log
     let level = 'log';
@@ -664,17 +661,20 @@ export class Parser {
       const connectionString = this.parseExpression();
       return new ASTNode('DbConnect', { connectionString });
     }
-    // db.query, db.find, etc -> treat as expression
-    this.pos -= 3; // rewind to parse as expression
+    this.pos -= 3;
     return this.parseExpressionStatement();
   }
 
+  parseDbDir() {
+    this.advance(); // db
+    const path = this.parseString();
+    return new ASTNode('DbDir', { path });
+  }
+
   parseAwaitStatement() {
-    // could be await expression or standalone await call
     return this.parseExpressionStatement();
   }
 
-  // [a, b] = await.all [expr1, expr2]
   parseAwaitAll() {
     this.advance(); // await.all
     const exprs = [];
@@ -696,7 +696,6 @@ export class Parser {
   parseExpressionStatement() {
     const expr = this.parseExpression();
 
-    // Check for assignment: expr = value
     if (this.match(T.ASSIGN)) {
       const value = this.parseExpression();
       return new ASTNode('Assignment', { target: expr, value });
@@ -713,7 +712,6 @@ export class Parser {
     return new ASTNode('ExprStatement', { expression: expr });
   }
 
-  // Expression parsing with precedence climbing
   parseExpression() {
     return this.parsePipe();
   }
@@ -730,27 +728,35 @@ export class Parser {
 
   matchPipeAcrossLines() {
     if (this.match(T.PIPE)) return true;
-    // Lookahead across newlines for pipe (INDENT/DEDENT already preprocessed)
     let scanPos = this.pos;
     while (scanPos < this.tokens.length && this.tokens[scanPos].type === T.NEWLINE) {
       scanPos++;
     }
     if (scanPos < this.tokens.length && this.tokens[scanPos].type === T.PIPE) {
       while (this.at(T.NEWLINE)) this.advance();
-      this.advance(); // consume PIPE
+      this.advance();
       return true;
     }
     return false;
   }
 
   parseTernary() {
+    if (this.at(T.IF)) {
+      const savedPos = this.pos;
+      this.advance();
+      const condition = this.parseNullish();
+      if (this.match(T.THEN)) {
+        const consequent = this.parseNullish();
+        this.expect(T.ELSE);
+        const alternate = this.parseNullish();
+        return new ASTNode('Ternary', { condition, consequent, alternate });
+      }
+      this.pos = savedPos;
+    }
     let expr = this.parseNullish();
-    // inline if: value = if cond then a else b
     if (this.at(T.IF)) {
-      // Only treat as ternary if we're in an expression context
-      // Lookahead: if ... then ... else
       const savedPos = this.pos;
-      this.advance(); // if
+      this.advance();
       const condition = this.parseNullish();
       if (this.match(T.THEN)) {
         const consequent = this.parseNullish();
@@ -758,7 +764,6 @@ export class Parser {
         const alternate = this.parseNullish();
         return new ASTNode('Ternary', { condition, consequent, alternate });
       }
-      // Not a ternary, restore
       this.pos = savedPos;
     }
     return expr;
@@ -922,12 +927,13 @@ export class Parser {
       case T.TYPE_STR: case T.TYPE_INT: case T.TYPE_NUM:
       case T.TYPE_BOOL: case T.TYPE_LIST: case T.TYPE_MAP:
       case T.TYPE_ANY: case T.TYPE_JSON: case T.TYPE_VOID:
-        // In expression context, type keywords act as identifiers (e.g., arr.map(), JSON.parse())
         this.advance();
         return new ASTNode('Identifier', { name: tok.value });
 
       case T.SCHEMA: case T.CRUD: case T.AUTH: case T.CORS:
       case T.LIMIT: case T.ENV: case T.EVERY: case T.WATCH:
+      case T.STATIC: case T.WS: case T.GROUP: case T.COOKIE:
+      case T.FROM: case T.AS: case T.IN:
         this.advance();
         return new ASTNode('Identifier', { name: tok.value });
 
@@ -1002,11 +1008,9 @@ export class Parser {
   }
 
   parseGroupOrArrow() {
-    // Check if this is an arrow function: (params) => body
     const savedPos = this.pos;
     this.advance(); // (
 
-    // Try to parse as arrow function params
     let isArrow = false;
     let depth = 1;
     let scanPos = this.pos;
@@ -1036,7 +1040,6 @@ export class Parser {
       return new ASTNode('ArrowFn', { params, body });
     }
 
-    // Regular grouping
     this.pos = savedPos;
     this.advance(); // (
     const expr = this.parseExpression();
@@ -1114,10 +1117,8 @@ export class Parser {
     return new ASTNode('Lambda', { params, returnType, body, isAsync });
   }
 
-  // schema User:
-  //   id     auto
-  //   name   str required min(2) max(50)
-  //   email  str required email unique
+  // ===== High-level feature parsers =====
+
   parseSchema() {
     this.advance(); // schema
     const name = this.expect(T.IDENT).value;
@@ -1184,7 +1185,6 @@ export class Parser {
     return { name, type: fieldType, enumValues, modifiers };
   }
 
-  // crud "/api/users" User
   parseCrud() {
     this.advance(); // crud
     const path = this.parseString();
@@ -1192,9 +1192,6 @@ export class Parser {
     return new ASTNode('CrudDecl', { path, schemaName });
   }
 
-  // auth SECRET:
-  //   protect "/api/*"
-  //   public "/api/auth/*"
   parseAuth() {
     this.advance(); // auth
     const secret = this.parseExpression();
@@ -1224,15 +1221,12 @@ export class Parser {
     return new ASTNode('AuthDecl', { secret, protectedPaths, publicPaths });
   }
 
-  // cors "*"
-  // cors ["origin1", "origin2"]
   parseCors() {
     this.advance(); // cors
     const origins = this.parseExpression();
     return new ASTNode('CorsDecl', { origins });
   }
 
-  // limit "/api/*" 100 "1m"
   parseLimit() {
     this.advance(); // limit
     const path = this.parseString();
@@ -1241,9 +1235,6 @@ export class Parser {
     return new ASTNode('LimitDecl', { path, max, window });
   }
 
-  // env:
-  //   PORT int default(3000)
-  //   JWT_SECRET str required
   parseEnv() {
     this.advance(); // env
     this.expect(T.COLON);
@@ -1296,8 +1287,6 @@ export class Parser {
     return { name, type: fieldType, modifiers };
   }
 
-  // every "5m":
-  //   log "tick"
   parseEvery() {
     this.advance(); // every
     const interval = this.parseExpression();
@@ -1306,8 +1295,6 @@ export class Parser {
     return new ASTNode('EveryDecl', { interval, body });
   }
 
-  // watch User.create (event):
-  //   log event
   parseWatch() {
     this.advance(); // watch
     let eventName = this.expect(T.IDENT).value;
@@ -1326,4 +1313,98 @@ export class Parser {
     const body = this.parseBlock();
     return new ASTNode('WatchDecl', { eventName, params, body });
   }
+
+  // static "/public"
+  parseStatic() {
+    this.advance(); // static
+    const path = this.parseString();
+    return new ASTNode('StaticDecl', { path });
+  }
+
+  // ws "/chat":
+  //   on "message" (data):
+  //     broadcast(data)
+  //   on "connect":
+  //     send({type: "welcome"})
+  parseWs() {
+    this.advance(); // ws
+    const path = this.parseString();
+    this.expect(T.COLON);
+    this.skipNewlines();
+    this.expect(T.INDENT);
+
+    const events = [];
+    this.skipNewlines();
+
+    while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
+      if (this.at(T.ON)) {
+        this.advance(); // on
+        const eventName = this.parseString();
+        let params = [];
+        if (this.match(T.LPAREN)) {
+          while (!this.at(T.RPAREN) && !this.at(T.EOF)) {
+            params.push(this.expect(T.IDENT).value);
+            this.match(T.COMMA);
+          }
+          this.expect(T.RPAREN);
+        }
+        this.expect(T.COLON);
+        const body = this.parseBlock();
+        events.push({ name: eventName, params, body });
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.match(T.DEDENT);
+
+    return new ASTNode('WsDecl', { path, events });
+  }
+
+  parseGroup() {
+    this.advance(); // group
+    const prefix = this.parseString();
+    this.expect(T.COLON);
+    this.skipNewlines();
+    this.expect(T.INDENT);
+
+    const routes = [];
+    this.skipNewlines();
+
+    while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
+      if (this.atAny(T.GET, T.POST, T.PUT, T.DEL)) {
+        routes.push(this.parseRoute());
+      } else if (this.at(T.MID)) {
+        routes.push(this.parseMiddleware());
+      } else if (this.at(T.CRUD)) {
+        routes.push(this.parseCrud());
+      } else if (this.at(T.AUTH)) {
+        routes.push(this.parseAuth());
+      } else if (this.at(T.GROUP)) {
+        routes.push(this.parseGroup());
+      } else {
+        routes.push(this.parseStatement());
+      }
+      this.skipNewlines();
+    }
+    this.match(T.DEDENT);
+
+    return new ASTNode('GroupDecl', { prefix, routes });
+  }
+
+  parseErrorHandler() {
+    this.advance(); // error (ident)
+    let params = ['err', 'req', 'res'];
+    if (this.match(T.LPAREN)) {
+      params = [];
+      while (!this.at(T.RPAREN) && !this.at(T.EOF)) {
+        params.push(this.expect(T.IDENT).value);
+        this.match(T.COMMA);
+      }
+      this.expect(T.RPAREN);
+    }
+    this.expect(T.COLON);
+    const body = this.parseBlock();
+    return new ASTNode('ErrorHandler', { params, body });
+  }
 }

package/src/preprocess.js

@@ -107,6 +107,14 @@ export function preprocess(source) {
       const rest = line.slice(1).trim();
       if (rest.startsWith('.s ') || rest.startsWith('.s(')) {
         out = 'ret.status ' + transformContent(rest.slice(3));
+      } else if (rest.startsWith('.r ')) {
+        out = 'ret.redirect ' + transformContent(rest.slice(3));
+      } else if (rest.startsWith('.h ')) {
+        out = 'ret.html ' + transformContent(rest.slice(3));
+      } else if (rest.startsWith('.t ')) {
+        out = 'ret.text ' + transformContent(rest.slice(3));
+      } else if (rest.startsWith('.f ')) {
+        out = 'ret.file ' + transformContent(rest.slice(3));
       } else {
         out = rest ? 'ret ' + transformContent(rest) : 'ret';
       }