feat(core): add "main" denotation of req extension

oscar60310 · oscar60310 · commit 79d4e1f06ba3 · 2022-06-01T11:29:35.000+08:00
add a new argument (the second one) of extension, its value should be "true" or "false", indicating
whether this builder is the final builder or not.
diff --git a/packages/core/src/lib/template-engine/extensions/tags/req.ts b/packages/core/src/lib/template-engine/extensions/tags/req.ts
@@ -7,6 +7,8 @@ import * as nunjucks from 'nunjucks';
 import { injectable, inject } from 'inversify';
 import { TYPES } from '@vulcan/core/containers';
 
+const FINIAL_BUILDER_NAME = 'FINAL_BUILDER';
+
 // TODO: temporary interface
 export interface QueryBuilder {
   count(): QueryBuilder;
@@ -29,37 +31,68 @@ export class ReqExtension implements NunjucksTagExtension {
 
   public parse(
     parser: nunjucks.parser.Parser,
-    nodes: typeof nunjucks.nodes
+    nodes: typeof nunjucks.nodes,
+    lexer: typeof nunjucks.lexer
   ): NunjucksTagExtensionParseResult {
-    // get the tag token
-    const token = parser.nextToken();
-
-    const args = parser.parseSignature(null, true);
-    parser.advanceAfterBlockEnd(token.value);
-
-    const requestQuery = parser.parseUntilBlocks('endreq');
-    parser.advanceAfterBlockEnd();
+    // {% req var (main) %} body {% endreq %}
+    // consume req tag
+    const reqToken = parser.nextToken();
+    // variable
+    let nextToken = parser.peekToken();
+    if (nextToken.type === lexer.TOKEN_BLOCK_END) {
+      // {% req %}
+      parser.fail(`Expected a variable`, nextToken.lineno, nextToken.colno);
+    }
+    if (nextToken.type !== lexer.TOKEN_SYMBOL) {
+      parser.fail(
+        `Expected a symbol, but got ${nextToken.type}`,
+        nextToken.lineno,
+        nextToken.colno
+      );
+    }
+    const variable = parser.parseExpression();
 
-    const variable = args.children[0];
-    if (!variable) {
-      parser.fail(`Expected a variable`, token.lineno, token.colno);
+    // main denotation
+    nextToken = parser.peekToken();
+    let mainBuilder = false;
+    if (nextToken.type !== lexer.TOKEN_BLOCK_END) {
+      if (nextToken.type !== lexer.TOKEN_SYMBOL || nextToken.value !== 'main') {
+        parser.fail(
+          `Expected a symbol "main"`,
+          nextToken.lineno,
+          nextToken.colno
+        );
+      }
+      mainBuilder = true;
+      // Consume this token (main)
+      parser.nextToken();
     }
-    if (!(variable instanceof nodes.Symbol)) {
+
+    const endToken = parser.nextToken();
+    if (endToken.type !== lexer.TOKEN_BLOCK_END) {
       parser.fail(
-        `Expected a symbol, but got ${variable.typename}`,
-        variable.lineno,
-        variable.colno
+        `Expected a block end, but got ${endToken.type}`,
+        endToken.lineno,
+        endToken.colno
       );
     }
 
-    const variableName = new nodes.Literal(
-      variable.colno,
-      variable.lineno,
-      (variable as nunjucks.nodes.Symbol).value
-    );
+    const requestQuery = parser.parseUntilBlocks('endreq');
+    parser.advanceAfterBlockEnd();
 
-    const argsNodeToPass = new nodes.NodeList(args.lineno, args.colno);
-    argsNodeToPass.addChild(variableName);
+    const argsNodeToPass = new nodes.NodeList(reqToken.lineno, reqToken.colno);
+    // variable name
+    argsNodeToPass.addChild(
+      new nodes.Literal(
+        variable.colno,
+        variable.lineno,
+        (variable as nunjucks.nodes.Symbol).value
+      )
+    );
+    // is main builder
+    argsNodeToPass.addChild(
+      new nodes.Literal(variable.colno, variable.lineno, String(mainBuilder))
+    );
 
     return {
       argsNodeList: argsNodeToPass,
@@ -69,12 +102,16 @@ export class ReqExtension implements NunjucksTagExtension {
 
   public async run({ context, args }: NunjucksTagExtensionRunOptions) {
     const name: string = args[0];
-    const requestQuery: () => string = args[1];
+    const requestQuery: () => string = args[2];
     const query = requestQuery()
       .split(/\r?\n/)
       .filter((line) => line.trim().length > 0)
       .join('\n');
     const builder = await this.executor.createBuilder(query);
     context.setVariable(name, builder);
+
+    if (Boolean(args[1])) {
+      context.setVariable(FINIAL_BUILDER_NAME, builder);
+    }
   }
 }
diff --git a/packages/core/test/template-engine/extensions/tags/req.spec.ts b/packages/core/test/template-engine/extensions/tags/req.spec.ts
@@ -38,7 +38,7 @@ afterEach(() => {
   container.unbindAll();
 });
 
-it('req extension should execute correct query and set variable', async () => {
+it.only('req extension should execute correct query and set variable', async () => {
   // Arrange
   const compiler = container.get<Compiler>(TYPES.Compiler);
   const loader = container.get<InMemoryCodeLoader>(TYPES.CompilerLoader);
@@ -72,7 +72,7 @@ it('if argument is not a symbol, extension should throw', async () => {
 select count(*) as count from user where user.id = '{{ params.userId }}';
 {% endreq %}
   `)
-  ).toThrow(`Expected a symbol, but got Literal`);
+  ).toThrow(`Expected a symbol, but got string`);
 });
 
 it('if argument is missing, extension should throw', async () => {
@@ -88,3 +88,38 @@ select count(*) as count from user where user.id = '{{ params.userId }}';
   `)
   ).toThrow(`Expected a variable`);
 });
+
+it('if the main denotation is replaces other keywords than "main", extension should throw an error', async () => {
+  // Arrange
+  const compiler = container.get<Compiler>(TYPES.Compiler);
+
+  // Action, Assert
+  expect(() =>
+    compiler.compile(`
+{% req user super %}
+some statement
+{% endreq %}
+  `)
+  ).toThrow(`Expected a symbol "main"`);
+});
+
+it('the main denotation should be parsed into the second args node', async () => {
+  // Arrange
+  const compiler = container.get<NunjucksCompiler>(TYPES.Compiler);
+
+  // Action
+  const { ast: astWithMainBuilder } = compiler.generateAst(
+    `{% req user main %} some statement {% endreq %}`
+  );
+  const { ast: astWithoutMainBuilder } = compiler.generateAst(
+    `{% req user %} some statement {% endreq %}`
+  );
+
+  // Assert
+  expect((astWithMainBuilder as any).children[0].args.children[1].value).toBe(
+    'true'
+  );
+  expect(
+    (astWithoutMainBuilder as any).children[0].args.children[1].value
+  ).toBe('false');
+});
diff --git a/types/nunjucks.d.ts b/types/nunjucks.d.ts
@@ -276,6 +276,7 @@ declare module 'nunjucks' {
       parseUntilBlocks(...blockName: string[]): nodes.NodeList;
       advanceAfterBlockEnd(): Token;
       fail(message: string, lineno?: number, colno?: number): void;
+      parseExpression(): Nodes;
     }
   }
 
@@ -345,6 +346,32 @@ declare module 'nunjucks' {
 
   namespace lexer {
     function lexer(src: string, opts: any): any;
+    const TOKEN_STRING: string;
+    const TOKEN_WHITESPACE: string;
+    const TOKEN_DATA: string;
+    const TOKEN_BLOCK_START: string;
+    const TOKEN_BLOCK_END: string;
+    const TOKEN_VARIABLE_START: string;
+    const TOKEN_VARIABLE_END: string;
+    const TOKEN_COMMENT: string;
+    const TOKEN_LEFT_PAREN: string;
+    const TOKEN_RIGHT_PAREN: string;
+    const TOKEN_LEFT_BRACKET: string;
+    const TOKEN_RIGHT_BRACKET: string;
+    const TOKEN_LEFT_CURLY: string;
+    const TOKEN_RIGHT_CURLY: string;
+    const TOKEN_OPERATOR: string;
+    const TOKEN_COMMA: string;
+    const TOKEN_COLON: string;
+    const TOKEN_TILDE: string;
+    const TOKEN_PIPE: string;
+    const TOKEN_INT: string;
+    const TOKEN_FLOAT: string;
+    const TOKEN_BOOLEAN: string;
+    const TOKEN_NONE: string;
+    const TOKEN_SYMBOL: string;
+    const TOKEN_SPECIAL: string;
+    const TOKEN_REGEX: string;
   }
 
   interface Token {
