tova 0.5.1 → 0.8.2

package/src/parser/edge-parser.js

@@ -0,0 +1,262 @@
+// Edge/serverless-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when edge { } blocks are encountered.
+
+import { TokenType } from '../lexer/tokens.js';
+import * as AST from './ast.js';
+import { installServerParser } from './server-parser.js';
+import {
+  EdgeConfigField, EdgeKVDeclaration, EdgeSQLDeclaration,
+  EdgeStorageDeclaration, EdgeQueueDeclaration, EdgeEnvDeclaration,
+  EdgeSecretDeclaration, EdgeScheduleDeclaration, EdgeConsumeDeclaration,
+} from './edge-ast.js';
+
+// Valid config keys inside edge blocks
+const EDGE_CONFIG_KEYS = new Set(['target']);
+
+// Valid edge targets
+const EDGE_TARGETS = new Set(['cloudflare', 'deno', 'vercel', 'lambda', 'bun']);
+
+// Edge binding keywords (contextual identifiers)
+const EDGE_BINDING_KEYWORDS = new Set(['kv', 'sql', 'storage', 'queue', 'env', 'secret']);
+
+export function installEdgeParser(ParserClass) {
+  if (ParserClass.prototype._edgeParserInstalled) return;
+  ParserClass.prototype._edgeParserInstalled = true;
+
+  // Edge reuses parseRoute() and parseMiddleware() from the server parser
+  installServerParser(ParserClass);
+
+  ParserClass.prototype.parseEdgeBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'edge'
+
+    // Optional name: edge "api" { }
+    let name = null;
+    if (this.check(TokenType.STRING)) {
+      name = this.advance().value;
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after 'edge'");
+    const body = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseEdgeStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close edge block");
+    return new AST.EdgeBlock(body, l, name);
+  };
+
+  ParserClass.prototype.parseEdgeStatement = function() {
+    // route keyword → reuse server route parser
+    if (this.check(TokenType.ROUTE)) {
+      // Ensure server parser is installed (for parseRoute)
+      return this.parseRoute();
+    }
+
+    // Contextual keywords in edge blocks
+    if (this.check(TokenType.IDENTIFIER)) {
+      const val = this.current().value;
+
+      // middleware fn name(req, next) { ... }
+      if (val === 'middleware' && this.peek(1).type === TokenType.FN) {
+        return this.parseMiddleware();
+      }
+
+      // kv BINDING_NAME or kv BINDING_NAME { config }
+      if (val === 'kv') {
+        return this.parseEdgeKV();
+      }
+
+      // sql BINDING_NAME
+      if (val === 'sql') {
+        return this.parseEdgeSQL();
+      }
+
+      // storage BINDING_NAME
+      if (val === 'storage') {
+        return this.parseEdgeStorage();
+      }
+
+      // queue BINDING_NAME
+      if (val === 'queue') {
+        return this.parseEdgeQueue();
+      }
+
+      // env VAR_NAME = default_value
+      if (val === 'env') {
+        return this.parseEdgeEnv();
+      }
+
+      // secret SECRET_NAME
+      if (val === 'secret') {
+        return this.parseEdgeSecret();
+      }
+
+      // schedule "name" cron("...") { body }
+      if (val === 'schedule') {
+        return this.parseEdgeSchedule();
+      }
+
+      // consume QUEUE_NAME fn(messages) { body }
+      if (val === 'consume') {
+        return this.parseEdgeConsume();
+      }
+
+      // health "/path"
+      if (val === 'health') {
+        return this.parseHealthCheck();
+      }
+
+      // cors { ... }
+      if (val === 'cors') {
+        return this.parseCorsConfig();
+      }
+
+      // on_error fn(err, req) { ... }
+      if (val === 'on_error') {
+        return this.parseErrorHandler();
+      }
+
+      // Config field: identifier: value (e.g., target: "cloudflare")
+      // Accept any identifier + colon pattern; analyzer validates the key
+      if (this.peek(1).type === TokenType.COLON && !EDGE_BINDING_KEYWORDS.has(val)) {
+        return this.parseEdgeConfigField();
+      }
+    }
+
+    // fn or async fn → regular function declaration
+    if (this.check(TokenType.FN) ||
+        (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FN)) {
+      return this.parseStatement();
+    }
+
+    // Fallback to regular statement
+    return this.parseStatement();
+  };
+
+  ParserClass.prototype.parseEdgeConfigField = function() {
+    const l = this.loc();
+    const key = this.advance().value; // consume identifier (e.g., 'target')
+    this.expect(TokenType.COLON, "Expected ':' after config key");
+    const value = this.parseExpression();
+    return new EdgeConfigField(key, value, l);
+  };
+
+  ParserClass.prototype.parseEdgeKV = function() {
+    const l = this.loc();
+    this.advance(); // consume 'kv'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected KV binding name").value;
+    let config = null;
+    if (this.check(TokenType.LBRACE)) {
+      config = this._parseEdgeBindingConfig();
+    }
+    return new EdgeKVDeclaration(name, config, l);
+  };
+
+  ParserClass.prototype.parseEdgeSQL = function() {
+    const l = this.loc();
+    this.advance(); // consume 'sql'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected SQL binding name").value;
+    let config = null;
+    if (this.check(TokenType.LBRACE)) {
+      config = this._parseEdgeBindingConfig();
+    }
+    return new EdgeSQLDeclaration(name, config, l);
+  };
+
+  ParserClass.prototype.parseEdgeStorage = function() {
+    const l = this.loc();
+    this.advance(); // consume 'storage'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected storage binding name").value;
+    let config = null;
+    if (this.check(TokenType.LBRACE)) {
+      config = this._parseEdgeBindingConfig();
+    }
+    return new EdgeStorageDeclaration(name, config, l);
+  };
+
+  ParserClass.prototype.parseEdgeQueue = function() {
+    const l = this.loc();
+    this.advance(); // consume 'queue'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected queue binding name").value;
+    let config = null;
+    if (this.check(TokenType.LBRACE)) {
+      config = this._parseEdgeBindingConfig();
+    }
+    return new EdgeQueueDeclaration(name, config, l);
+  };
+
+  ParserClass.prototype.parseEdgeEnv = function() {
+    const l = this.loc();
+    this.advance(); // consume 'env'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected env var name").value;
+    let defaultValue = null;
+    if (this.match(TokenType.ASSIGN)) {
+      defaultValue = this.parseExpression();
+    }
+    return new EdgeEnvDeclaration(name, defaultValue, l);
+  };
+
+  ParserClass.prototype.parseEdgeSecret = function() {
+    const l = this.loc();
+    this.advance(); // consume 'secret'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected secret name").value;
+    return new EdgeSecretDeclaration(name, l);
+  };
+
+  ParserClass.prototype.parseEdgeSchedule = function() {
+    const l = this.loc();
+    this.advance(); // consume 'schedule'
+    const name = this.expect(TokenType.STRING, "Expected schedule name string").value;
+
+    // cron("expression")
+    const cronIdent = this.expect(TokenType.IDENTIFIER, "Expected 'cron' after schedule name");
+    if (cronIdent.value !== 'cron') {
+      this.error("Expected 'cron' keyword after schedule name");
+    }
+    this.expect(TokenType.LPAREN, "Expected '(' after 'cron'");
+    const cronExpr = this.expect(TokenType.STRING, "Expected cron expression string").value;
+    this.expect(TokenType.RPAREN, "Expected ')' after cron expression");
+
+    const body = this.parseBlock();
+    return new EdgeScheduleDeclaration(name, cronExpr, body, l);
+  };
+
+  ParserClass.prototype.parseEdgeConsume = function() {
+    const l = this.loc();
+    this.advance(); // consume 'consume'
+    const queue = this.expect(TokenType.IDENTIFIER, "Expected queue name").value;
+
+    // fn(messages) { ... } or a function reference
+    this.expect(TokenType.FN, "Expected 'fn' after queue name in consume");
+    this.expect(TokenType.LPAREN, "Expected '(' after 'fn'");
+    const params = this.parseParameterList();
+    this.expect(TokenType.RPAREN, "Expected ')' after consume parameters");
+    const body = this.parseBlock();
+
+    const handler = new AST.LambdaExpression(params, body, l);
+    return new EdgeConsumeDeclaration(queue, handler, l);
+  };
+
+  // Helper: parse { key: value, ... } config block for bindings
+  ParserClass.prototype._parseEdgeBindingConfig = function() {
+    this.expect(TokenType.LBRACE, "Expected '{' for binding config");
+    const config = {};
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected config key").value;
+      this.expect(TokenType.COLON, "Expected ':' after config key");
+      const value = this.parseExpression();
+      config[key] = value;
+      this.match(TokenType.COMMA);
+    }
+    this.expect(TokenType.RBRACE, "Expected '}' to close binding config");
+    return config;
+  };
+}

package/src/parser/form-ast.js

@@ -0,0 +1,80 @@
+// Form-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when form { } blocks are used.
+
+// ============================================================
+// Form-specific nodes
+// ============================================================
+
+export class FormDeclaration {
+  constructor(name, typeAnnotation, fields, groups, arrays, computeds, steps, onSubmit, loc) {
+    this.type = 'FormDeclaration';
+    this.name = name;
+    this.typeAnnotation = typeAnnotation;
+    this.fields = fields;
+    this.groups = groups;
+    this.arrays = arrays;
+    this.computeds = computeds;
+    this.steps = steps;
+    this.onSubmit = onSubmit;
+    this.loc = loc;
+  }
+}
+
+export class FormFieldDeclaration {
+  constructor(name, typeAnnotation, initialValue, validators, loc) {
+    this.type = 'FormFieldDeclaration';
+    this.name = name;
+    this.typeAnnotation = typeAnnotation;
+    this.initialValue = initialValue;
+    this.validators = validators;
+    this.loc = loc;
+  }
+}
+
+export class FormGroupDeclaration {
+  constructor(name, condition, fields, groups, loc) {
+    this.type = 'FormGroupDeclaration';
+    this.name = name;
+    this.condition = condition;
+    this.fields = fields;
+    this.groups = groups;
+    this.loc = loc;
+  }
+}
+
+export class FormArrayDeclaration {
+  constructor(name, fields, validators, loc) {
+    this.type = 'FormArrayDeclaration';
+    this.name = name;
+    this.fields = fields;
+    this.validators = validators;
+    this.loc = loc;
+  }
+}
+
+export class FormValidator {
+  constructor(name, args, isAsync, loc) {
+    this.type = 'FormValidator';
+    this.name = name;
+    this.args = args;
+    this.isAsync = isAsync;
+    this.loc = loc;
+  }
+}
+
+export class FormStepsDeclaration {
+  constructor(steps, loc) {
+    this.type = 'FormStepsDeclaration';
+    this.steps = steps;
+    this.loc = loc;
+  }
+}
+
+export class FormStep {
+  constructor(label, members, loc) {
+    this.type = 'FormStep';
+    this.label = label;
+    this.members = members;
+    this.loc = loc;
+  }
+}

package/src/parser/form-parser.js

@@ -0,0 +1,206 @@
+// Form-specific parser methods for the Tova language
+// Extracted for lazy loading — only loaded when form { } blocks are encountered.
+
+import {
+  FormDeclaration, FormFieldDeclaration, FormGroupDeclaration,
+  FormArrayDeclaration, FormValidator, FormStepsDeclaration, FormStep,
+} from './form-ast.js';
+import { TokenType } from '../lexer/tokens.js';
+
+export function installFormParser(ParserClass) {
+  if (ParserClass.prototype._formParserInstalled) return;
+  ParserClass.prototype._formParserInstalled = true;
+
+  ParserClass.prototype.parseFormDeclaration = function() {
+    const l = this.loc();
+    this.expect(TokenType.FORM);
+    const name = this.expect(TokenType.IDENTIFIER, "Expected form name").value;
+
+    let typeAnnotation = null;
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.parseTypeAnnotation();
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after form name");
+
+    const fields = [];
+    const groups = [];
+    const arrays = [];
+    const computeds = [];
+    let steps = null;
+    let onSubmit = null;
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      if (this.check(TokenType.FIELD)) {
+        fields.push(this.parseFormField());
+      } else if (this.check(TokenType.GROUP)) {
+        groups.push(this.parseFormGroup());
+      } else if (this._checkFormContextual('array')) {
+        arrays.push(this.parseFormArray());
+      } else if (this.check(TokenType.COMPUTED)) {
+        computeds.push(this.parseComputed());
+      } else if (this.check(TokenType.STEPS)) {
+        steps = this.parseFormSteps();
+      } else if (this._checkFormContextual('on') && this._peekFormContextual(1, 'submit')) {
+        onSubmit = this.parseFormOnSubmit();
+      } else {
+        this.error("Expected 'field', 'group', 'array', 'computed', 'steps', or 'on submit' inside form block");
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close form block");
+    return new FormDeclaration(name, typeAnnotation, fields, groups, arrays, computeds, steps, onSubmit, l);
+  };
+
+  ParserClass.prototype.parseFormField = function() {
+    const l = this.loc();
+    this.expect(TokenType.FIELD);
+    const name = this.expect(TokenType.IDENTIFIER, "Expected field name").value;
+
+    let typeAnnotation = null;
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.parseTypeAnnotation();
+    }
+
+    let initialValue = null;
+    if (this.match(TokenType.ASSIGN)) {
+      initialValue = this.parseExpression();
+    }
+
+    const validators = [];
+    if (this.check(TokenType.LBRACE)) {
+      this.advance(); // consume {
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        validators.push(this.parseFormValidator());
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close validator block");
+    }
+
+    return new FormFieldDeclaration(name, typeAnnotation, initialValue, validators, l);
+  };
+
+  ParserClass.prototype.parseFormValidator = function() {
+    const l = this.loc();
+    let isAsync = false;
+    if (this.check(TokenType.ASYNC)) {
+      isAsync = true;
+      this.advance();
+    }
+    const name = this.expect(TokenType.IDENTIFIER, "Expected validator name").value;
+
+    const args = [];
+    if (this.match(TokenType.LPAREN)) {
+      if (!this.check(TokenType.RPAREN)) {
+        args.push(this.parseExpression());
+        while (this.match(TokenType.COMMA)) {
+          args.push(this.parseExpression());
+        }
+      }
+      this.expect(TokenType.RPAREN, "Expected ')' after validator arguments");
+    }
+
+    return new FormValidator(name, args, isAsync, l);
+  };
+
+  ParserClass.prototype.parseFormGroup = function() {
+    const l = this.loc();
+    this.expect(TokenType.GROUP);
+    const name = this.expect(TokenType.IDENTIFIER, "Expected group name").value;
+
+    let condition = null;
+    if (this.check(TokenType.WHEN)) {
+      this.advance(); // consume 'when'
+      condition = this.parseExpression();
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after group name");
+
+    const fields = [];
+    const groups = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      if (this.check(TokenType.FIELD)) {
+        fields.push(this.parseFormField());
+      } else if (this.check(TokenType.GROUP)) {
+        groups.push(this.parseFormGroup());
+      } else {
+        this.error("Expected 'field' or 'group' inside form group");
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close group block");
+    return new FormGroupDeclaration(name, condition, fields, groups, l);
+  };
+
+  ParserClass.prototype.parseFormArray = function() {
+    const l = this.loc();
+    this.advance(); // consume 'array' (contextual keyword — it's an IDENTIFIER with value "array")
+    const name = this.expect(TokenType.IDENTIFIER, "Expected array name").value;
+
+    this.expect(TokenType.LBRACE, "Expected '{' after array name");
+
+    const fields = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      if (this.check(TokenType.FIELD)) {
+        fields.push(this.parseFormField());
+      } else {
+        this.error("Expected 'field' inside form array");
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close array block");
+    return new FormArrayDeclaration(name, fields, [], l);
+  };
+
+  ParserClass.prototype.parseFormSteps = function() {
+    const l = this.loc();
+    this.expect(TokenType.STEPS);
+    this.expect(TokenType.LBRACE, "Expected '{' after steps");
+
+    const stepsArr = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      stepsArr.push(this.parseFormStep());
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close steps block");
+    return new FormStepsDeclaration(stepsArr, l);
+  };
+
+  ParserClass.prototype.parseFormStep = function() {
+    const l = this.loc();
+    if (!this._checkFormContextual('step')) {
+      this.error("Expected 'step' inside steps block");
+    }
+    this.advance(); // consume 'step'
+    const label = this.expect(TokenType.STRING, "Expected step label string").value;
+    this.expect(TokenType.LBRACE, "Expected '{' after step label");
+
+    const members = [];
+    members.push(this.expect(TokenType.IDENTIFIER, "Expected field/group/array name").value);
+    while (this.match(TokenType.COMMA)) {
+      members.push(this.expect(TokenType.IDENTIFIER, "Expected field/group/array name").value);
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close step");
+    return new FormStep(label, members, l);
+  };
+
+  ParserClass.prototype.parseFormOnSubmit = function() {
+    this.advance(); // consume 'on'
+    this.advance(); // consume 'submit'
+    return this.parseBlock();
+  };
+
+  // Helper: check if current token is an identifier with a specific value
+  if (!ParserClass.prototype._checkFormContextual) {
+    ParserClass.prototype._checkFormContextual = function(name) {
+      return this.check(TokenType.IDENTIFIER) && this.current().value === name;
+    };
+  }
+
+  if (!ParserClass.prototype._peekFormContextual) {
+    ParserClass.prototype._peekFormContextual = function(offset, name) {
+      const token = this.peek(offset);
+      return token && token.type === TokenType.IDENTIFIER && token.value === name;
+    };
+  }
+}