naidejs 1.2.0 → 1.4.0

package/src/parser.js

@@ -61,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;
   }
@@ -81,18 +90,28 @@ 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 ||
+      type === T.UPLOAD || type === T.SESSION || type === T.VIEW ||
+      type === T.SSE || type === T.CACHE || type === T.PATCH || type === T.MID ||
+      type === T.VALIDATE || type === T.TEST || type === T.ASSERT ||
+      type === T.QUEUE || type === T.JOB || type === T.OPENAPI;
+  }
+
   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 ||
-        tok.type === T.STATIC || tok.type === T.WS ||
-        tok.type === T.GROUP || tok.type === T.COOKIE) {
+    if (this.isIdentLike(tok.type)) {
       return tok.value;
     }
     throw this.error(`Expected property name but got ${tok.type} ('${tok.value}')`, tok);
@@ -186,6 +205,18 @@ export class Parser {
         if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
         this.advance();
         return new ASTNode('CookieDecl');
+      case T.VALIDATE:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseValidate();
+      case T.TEST:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseTest();
+      case T.ASSERT:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseAssert();
+      case T.QUEUE:
+        if (this.peek(1).type === T.DOT) return this.parseExpressionStatement();
+        return this.parseQueue();
       default:
         if (TYPE_TOKENS.has(tok.type)) {
           return this.parseTypedVariable();
@@ -237,7 +268,11 @@ export class Parser {
 
   parseFunction(isAsync, isPublic) {
     this.advance(); // fn or fn.async
-    const name = this.expect(T.IDENT).value;
+    const tok = this.advance();
+    if (!this.isIdentLike(tok.type)) {
+      throw this.error(`Expected function name but got ${tok.type} ('${tok.value}')`, tok);
+    }
+    const name = tok.value;
     this.expect(T.LPAREN);
     const params = this.parseFnParams();
     this.expect(T.RPAREN);
@@ -328,6 +363,14 @@ export class Parser {
         const body = this.parseExpression();
         return new ASTNode('ReturnStatus', { method, statusCode, body });
       }
+      if (method === 'render') {
+        const template = this.parseExpression();
+        let data = null;
+        if (!this.at(T.NEWLINE) && !this.at(T.EOF) && !this.at(T.DEDENT)) {
+          data = this.parseExpression();
+        }
+        return new ASTNode('ReturnRender', { template, data });
+      }
       const value = this.parseExpression();
       return new ASTNode('ReturnMethod', { method, value });
     }
@@ -499,10 +542,15 @@ export class Parser {
     this.skipNewlines();
 
     while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
-      if (this.atAny(T.GET, T.POST, T.PUT, T.DEL)) {
+      if (this.atAny(T.GET, T.POST, T.PUT, T.DEL, T.PATCH)) {
         routes.push(this.parseRoute());
       } else if (this.at(T.MID)) {
-        middleware.push(this.parseMiddleware());
+        const mid = this.parseMiddleware();
+        if (mid.type === 'MiddlewareRef') {
+          routes.push(mid);
+        } else {
+          middleware.push(mid);
+        }
       } else if (this.at(T.CRUD)) {
         routes.push(this.parseCrud());
       } else if (this.at(T.AUTH)) {
@@ -520,6 +568,22 @@ export class Parser {
       } else if (this.at(T.COOKIE)) {
         this.advance();
         routes.push(new ASTNode('CookieDecl'));
+      } else if (this.at(T.UPLOAD)) {
+        routes.push(this.parseUpload());
+      } else if (this.at(T.SESSION)) {
+        routes.push(this.parseSession());
+      } else if (this.at(T.VIEW)) {
+        routes.push(this.parseView());
+      } else if (this.at(T.SSE)) {
+        routes.push(this.parseSse());
+      } else if (this.at(T.CACHE)) {
+        routes.push(this.parseCache());
+      } else if (this.at(T.VALIDATE)) {
+        routes.push(this.parseValidate());
+      } else if (this.at(T.OPENAPI)) {
+        routes.push(this.parseOpenapi());
+      } else if (this.at(T.QUEUE)) {
+        routes.push(this.parseQueue());
       } else if (this.at(T.IDENT) && this.peek().value === 'error') {
         routes.push(this.parseErrorHandler());
       } else {
@@ -559,16 +623,23 @@ export class Parser {
   parseMiddleware() {
     this.advance(); // mid
     const name = this.expect(T.IDENT).value;
-    this.expect(T.LPAREN);
-    const params = [];
-    while (!this.at(T.RPAREN) && !this.at(T.EOF)) {
-      params.push(this.expect(T.IDENT).value);
-      this.match(T.COMMA);
+    if (this.at(T.LPAREN)) {
+      this.advance();
+      const 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('Middleware', { name, params, body });
     }
-    this.expect(T.RPAREN);
-    this.expect(T.COLON);
-    const body = this.parseBlock();
-    return new ASTNode('Middleware', { name, params, body });
+    let path = null;
+    if (this.at(T.STRING)) {
+      path = this.parseString();
+    }
+    return new ASTNode('MiddlewareRef', { name, path });
   }
 
   parseModel(isPublic = false) {
@@ -726,6 +797,18 @@ export class Parser {
   }
 
   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();
     if (this.at(T.IF)) {
       const savedPos = this.pos;
@@ -906,6 +989,11 @@ export class Parser {
       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.UPLOAD: case T.SESSION: case T.VIEW: case T.SSE:
+      case T.CACHE: case T.PATCH: case T.MID:
+      case T.VALIDATE: case T.TEST: case T.ASSERT:
+      case T.QUEUE: case T.JOB: case T.OPENAPI:
+      case T.FROM: case T.AS: case T.IN:
         this.advance();
         return new ASTNode('Identifier', { name: tok.value });
 
@@ -1344,7 +1432,7 @@ export class Parser {
     this.skipNewlines();
 
     while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
-      if (this.atAny(T.GET, T.POST, T.PUT, T.DEL)) {
+      if (this.atAny(T.GET, T.POST, T.PUT, T.DEL, T.PATCH)) {
         routes.push(this.parseRoute());
       } else if (this.at(T.MID)) {
         routes.push(this.parseMiddleware());
@@ -1379,4 +1467,108 @@ export class Parser {
     const body = this.parseBlock();
     return new ASTNode('ErrorHandler', { params, body });
   }
+
+  parseUpload() {
+    this.advance(); // upload
+    const path = this.parseString();
+    const fieldName = 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();
+    return new ASTNode('UploadDecl', { path, fieldName, params, body });
+  }
+
+  parseSession() {
+    this.advance(); // session
+    const secret = this.parseExpression();
+    return new ASTNode('SessionDecl', { secret });
+  }
+
+  parseView() {
+    this.advance(); // view
+    const dir = this.parseString();
+    return new ASTNode('ViewDecl', { dir });
+  }
+
+  parseSse() {
+    this.advance(); // sse
+    const path = this.parseString();
+    return new ASTNode('SseDecl', { path });
+  }
+
+  parseCache() {
+    this.advance(); // cache
+    const path = this.parseString();
+    const duration = this.parseExpression();
+    return new ASTNode('CacheDecl', { path, duration });
+  }
+
+  parseValidate() {
+    this.advance(); // validate
+    const path = this.parseString();
+    const schemaName = this.expect(T.IDENT).value;
+    return new ASTNode('ValidateDecl', { path, schemaName });
+  }
+
+  parseTest() {
+    this.advance(); // test
+    const name = this.parseExpression();
+    this.expect(T.COLON);
+    const body = this.parseBlock();
+    return new ASTNode('TestDecl', { name, body });
+  }
+
+  parseAssert() {
+    this.advance(); // assert
+    const expr = this.parseExpression();
+    return new ASTNode('AssertStmt', { expr });
+  }
+
+  parseQueue() {
+    this.advance(); // queue
+    const name = this.expect(T.IDENT).value;
+    this.expect(T.COLON);
+    this.skipNewlines();
+    this.expect(T.INDENT);
+
+    const jobs = [];
+    this.skipNewlines();
+
+    while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
+      if (this.at(T.JOB)) {
+        this.advance();
+        const jobName = 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();
+        jobs.push({ name: jobName, params, body });
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.match(T.DEDENT);
+
+    return new ASTNode('QueueDecl', { name, jobs });
+  }
+
+  parseOpenapi() {
+    this.advance(); // openapi
+    const path = this.parseString();
+    return new ASTNode('OpenapiDecl', { path });
+  }
 }

package/src/preprocess.js

@@ -115,6 +115,8 @@ export function preprocess(source) {
         out = 'ret.text ' + transformContent(rest.slice(3));
       } else if (rest.startsWith('.f ')) {
         out = 'ret.file ' + transformContent(rest.slice(3));
+      } else if (rest.startsWith('.v ')) {
+        out = 'ret.render ' + transformContent(rest.slice(3));
       } else {
         out = rest ? 'ret ' + transformContent(rest) : 'ret';
       }
@@ -179,6 +181,7 @@ export function preprocess(source) {
     else if (first === 'P' && second === '"') { out = transformRoute('post', line.slice(1)); }
     else if (first === 'U' && second === '"') { out = transformRoute('put', line.slice(1)); }
     else if (first === 'D' && second === '"') { out = transformRoute('del', line.slice(1)); }
+    else if (first === 'X' && second === '"') { out = transformRoute('patch', line.slice(1)); }
     // ^ model
     else if (first === '^') {
       const rest = line.slice(1).trim();

package/src/runtime.js

@@ -408,6 +408,264 @@ export function cookieParser() {
   };
 }
 
+// ===== Session Middleware (zero-dep, cookie-based) =====
+export function sessionMiddleware(secret) {
+  const store = new Map();
+  const maxAge = 86400000;
+  return (req, res, next) => {
+    const cookies = req.headers.cookie || '';
+    const sidMatch = cookies.match(/(?:^|;\s*)naide_sid=([^;]+)/);
+    let sid = sidMatch ? sidMatch[1] : null;
+    if (!sid || !store.has(sid)) {
+      sid = randomUUID();
+      store.set(sid, {});
+    }
+    req.session = store.get(sid);
+    req.sessionId = sid;
+    req.session.destroy = () => { store.delete(sid); };
+    const origWriteHead = res.writeHead;
+    res.writeHead = function(...args) {
+      res.setHeader('Set-Cookie', `naide_sid=${sid}; HttpOnly; Path=/; Max-Age=${maxAge / 1000}; SameSite=Lax`);
+      origWriteHead.apply(res, args);
+    };
+    for (const [id, data] of store) {
+      if (data.__ts && Date.now() - data.__ts > maxAge) store.delete(id);
+    }
+    req.session.__ts = Date.now();
+    next();
+  };
+}
+
+// ===== Template Renderer (zero-dep) =====
+export function createRenderer(viewsDir) {
+  return (name, data = {}) => {
+    const filePath = viewsDir.replace(/\/$/, '') + '/' + name + (name.includes('.') ? '' : '.html');
+    let template = readFileSync(filePath, 'utf-8');
+    template = template.replace(/\{\{\s*each\s+(\w+)\s+in\s+(\w+)\s*\}\}([\s\S]*?)\{\{\s*\/each\s*\}\}/g, (_, item, list, block) => {
+      const arr = data[list] || [];
+      return arr.map(val => block.replace(new RegExp(`\\{\\{\\s*${item}\\b[^}]*\\}\\}`, 'g'), m => {
+        const prop = m.match(/\{\{\s*\w+\.(\w+)\s*\}\}/);
+        return prop ? String(val[prop[1]] ?? '') : String(val ?? '');
+      })).join('');
+    });
+    template = template.replace(/\{\{\s*if\s+(\w+)\s*\}\}([\s\S]*?)\{\{\s*\/if\s*\}\}/g, (_, key, block) => data[key] ? block : '');
+    for (const [key, value] of Object.entries(data)) {
+      template = template.replace(new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g'), String(value ?? ''));
+    }
+    return template;
+  };
+}
+
+// ===== Cache Middleware (zero-dep) =====
+export function cacheMiddleware(duration) {
+  const maxAge = parseMs(duration);
+  const cache = new Map();
+  return (req, res, next) => {
+    if (req.method !== 'GET') return next();
+    const key = req.originalUrl || req.url;
+    const cached = cache.get(key);
+    if (cached && Date.now() - cached.time < maxAge) {
+      res.setHeader('X-Cache', 'HIT');
+      const ct = cached.contentType || 'application/json';
+      res.setHeader('Content-Type', ct);
+      return res.end(cached.body);
+    }
+    const origEnd = res.end;
+    const origJson = res.json ? res.json.bind(res) : null;
+    if (origJson) {
+      res.json = (data) => {
+        cache.set(key, { body: JSON.stringify(data), contentType: 'application/json', time: Date.now() });
+        res.setHeader('X-Cache', 'MISS');
+        origJson(data);
+      };
+    }
+    const origSend = res.send ? res.send.bind(res) : null;
+    if (origSend) {
+      res.send = (body) => {
+        cache.set(key, { body: String(body), contentType: res.getHeader('content-type'), time: Date.now() });
+        res.setHeader('X-Cache', 'MISS');
+        origSend(body);
+      };
+    }
+    next();
+  };
+}
+
+// ===== Upload Middleware (zero-dep multipart parser) =====
+export function uploadMiddleware(fieldName, opts = {}) {
+  const maxSize = opts.maxSize || 10 * 1024 * 1024;
+  return (req, res, next) => {
+    const contentType = req.headers['content-type'] || '';
+    if (!contentType.startsWith('multipart/form-data')) return next();
+    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
+    if (!boundaryMatch) return next();
+    const boundary = boundaryMatch[1] || boundaryMatch[2];
+    const chunks = [];
+    let size = 0;
+    req.on('data', chunk => {
+      size += chunk.length;
+      if (size > maxSize) { req.destroy(); return res.status(413).json({ error: 'File too large' }); }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        const buffer = Buffer.concat(chunks);
+        const { files, fields } = _parseMultipart(buffer, boundary);
+        req.files = files;
+        req.file = files[fieldName] || files[Object.keys(files)[0]] || null;
+        if (!req.body) req.body = {};
+        Object.assign(req.body, fields);
+        next();
+      } catch { res.status(400).json({ error: 'Invalid multipart data' }); }
+    });
+    req.on('error', () => res.status(400).json({ error: 'Upload failed' }));
+  };
+}
+
+function _parseMultipart(buffer, boundary) {
+  const files = {}, fields = {};
+  const delim = Buffer.from(`--${boundary}`);
+  let start = buffer.indexOf(delim);
+  if (start === -1) return { files, fields };
+  start += delim.length + 2;
+  const endDelim = Buffer.from(`--${boundary}--`);
+  while (start < buffer.length) {
+    let end = buffer.indexOf(delim, start);
+    if (end === -1) break;
+    const part = buffer.slice(start, end - 2);
+    const headerEnd = part.indexOf('\r\n\r\n');
+    if (headerEnd !== -1) {
+      const header = part.slice(0, headerEnd).toString('utf-8');
+      const body = part.slice(headerEnd + 4);
+      const nameMatch = header.match(/name="([^"]+)"/);
+      if (nameMatch) {
+        const filenameMatch = header.match(/filename="([^"]+)"/);
+        if (filenameMatch) {
+          const ctMatch = header.match(/Content-Type:\s*(.+)/i);
+          files[nameMatch[1]] = { filename: filenameMatch[1], contentType: ctMatch ? ctMatch[1].trim() : 'application/octet-stream', data: body, size: body.length };
+        } else {
+          fields[nameMatch[1]] = body.toString('utf-8');
+        }
+      }
+    }
+    start = end + delim.length;
+    if (buffer.slice(end, end + endDelim.length).equals(endDelim)) break;
+    start += 2;
+  }
+  return { files, fields };
+}
+
+// ===== SSE Manager (zero-dep) =====
+export function createSseManager() {
+  const clients = new Set();
+  return {
+    handler() {
+      return (req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*' });
+        res.write(':\n\n');
+        const client = { res, id: randomUUID() };
+        clients.add(client);
+        req.on('close', () => clients.delete(client));
+      };
+    },
+    send(data, event) {
+      const payload = typeof data === 'string' ? data : JSON.stringify(data);
+      for (const client of clients) {
+        if (event) client.res.write(`event: ${event}\n`);
+        client.res.write(`data: ${payload}\n\n`);
+      }
+    },
+    broadcast(data, event) { this.send(data, event); },
+    get count() { return clients.size; }
+  };
+}
+
+// ===== Validate Middleware =====
+export function validateMiddleware(schema) {
+  return (req, res, next) => {
+    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+      const result = schema.validate(req.body || {});
+      if (!result.valid) {
+        return res.status(400).json({ errors: result.errors });
+      }
+      req.body = result.data;
+    }
+    next();
+  };
+}
+
+// ===== Job Queue (in-memory async) =====
+export function createQueue() {
+  const handlers = new Map();
+  const pending = [];
+  let running = false;
+
+  async function process() {
+    if (running) return;
+    running = true;
+    while (pending.length > 0) {
+      const { name, data, resolve, reject } = pending.shift();
+      const handler = handlers.get(name);
+      if (handler) {
+        try { await handler(data); resolve(); } catch (e) { console.error('[NAIDE Queue]', e.message); reject(e); }
+      } else {
+        reject(new Error(`No handler for job: ${name}`));
+      }
+    }
+    running = false;
+  }
+
+  return {
+    register(name, fn) { handlers.set(name, fn); },
+    add(name, data) {
+      return new Promise((resolve, reject) => {
+        pending.push({ name, data, resolve, reject });
+        process();
+      });
+    },
+    get size() { return pending.length; }
+  };
+}
+
+// ===== OpenAPI Spec Builder =====
+export function buildOpenApiSpec(schemas) {
+  const spec = {
+    openapi: '3.1.0',
+    info: { title: 'API', version: '1.0.0' },
+    paths: {},
+    components: { schemas: {} }
+  };
+  for (const schema of schemas) {
+    const properties = {};
+    const required = [];
+    for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+      const prop = {};
+      switch (fieldDef.type) {
+        case 'id': prop.type = 'string'; prop.format = 'uuid'; break;
+        case 'string': prop.type = 'string'; break;
+        case 'integer': prop.type = 'integer'; break;
+        case 'number': prop.type = 'number'; break;
+        case 'boolean': prop.type = 'boolean'; break;
+        case 'timestamp': prop.type = 'string'; prop.format = 'date-time'; break;
+        case 'enum':
+          prop.type = 'string';
+          if (fieldDef.values) prop.enum = fieldDef.values;
+          break;
+        default: prop.type = 'string';
+      }
+      if (fieldDef.min !== undefined) prop.minimum = fieldDef.min;
+      if (fieldDef.max !== undefined) prop.maximum = fieldDef.max;
+      if (fieldDef.email) prop.format = 'email';
+      if (fieldDef.url) prop.format = 'uri';
+      properties[fieldName] = prop;
+      if (fieldDef.required) required.push(fieldName);
+    }
+    spec.components.schemas[schema.name] = { type: 'object', properties };
+    if (required.length > 0) spec.components.schemas[schema.name].required = required;
+  }
+  return spec;
+}
+
 // ===== Helpers =====
 function parseMs(str) {
   if (typeof str === 'number') return str;

package/src/tokens.js

@@ -69,6 +69,18 @@ export const T = {
   WS: 'WS',
   GROUP: 'GROUP',
   COOKIE: 'COOKIE',
+  UPLOAD: 'UPLOAD',
+  SESSION: 'SESSION',
+  VIEW: 'VIEW',
+  SSE: 'SSE',
+  CACHE: 'CACHE',
+  PATCH: 'PATCH',
+  VALIDATE: 'VALIDATE',
+  TEST: 'TEST',
+  ASSERT: 'ASSERT',
+  QUEUE: 'QUEUE',
+  JOB: 'JOB',
+  OPENAPI: 'OPENAPI',
 
   // Operators
   ASSIGN: 'ASSIGN',
@@ -166,6 +178,18 @@ export const KEYWORDS = {
   'ws': T.WS,
   'group': T.GROUP,
   'cookie': T.COOKIE,
+  'upload': T.UPLOAD,
+  'session': T.SESSION,
+  'view': T.VIEW,
+  'sse': T.SSE,
+  'cache': T.CACHE,
+  'patch': T.PATCH,
+  'validate': T.VALIDATE,
+  'test': T.TEST,
+  'assert': T.ASSERT,
+  'queue': T.QUEUE,
+  'job': T.JOB,
+  'openapi': T.OPENAPI,
   'true': T.BOOL,
   'false': T.BOOL,
   'null': T.NULL,