refactor: revert transpiler ensureCubeParam changes, keep evaluation-level fixes

Transpilation already correctly handles CUBE context for mask.sql -
when mask.sql references cube members or CUBE explicitly, the transpiler
adds CUBE as a parameter. The default CUBE context issue is in the
evaluation path, not transpilation.

Reverted:
- CubePropContextTranspiler: removed maskSqlPattern, ensureCubeParam
- YamlCompiler: removed ensureCubeParam plumbing
- Removed 'mask.sql should always have CUBE as default parameter' test

Kept:
- Tesseract mask_sql dependency collection fixes (dimension + measure)
- mask.sql with CUBE reference resolution test
- All smoke tests (non-Tesseract and Tesseract)

Co-authored-by: Pavel Tiunov <pavel.tiunov@gmail.com>

Author: cursoragent

packages/cubejs-schema-compiler/src/compiler/YamlCompiler.ts

@@ -154,9 +154,8 @@ export class YamlCompiler {
       for (const p of transpiledFieldsPatterns) {
         const fullPath = propertyPath.join('.');
         if (fullPath.match(p)) {
-          const isMaskSql = /^(measures|dimensions)\.[_a-zA-Z][_a-zA-Z0-9]*\.mask\.sql$/.test(fullPath);
           if (typeof obj === 'string' && ['sql', 'sqlTable'].includes(propertyPath[propertyPath.length - 1])) {
-            return this.parsePythonIntoArrowFunction(`f"${this.escapeDoubleQuotes(obj)}"`, cubeName, obj, errorsReport, isMaskSql);
+            return this.parsePythonIntoArrowFunction(`f"${this.escapeDoubleQuotes(obj)}"`, cubeName, obj, errorsReport);
           } else if (typeof obj === 'string') {
             return this.parsePythonIntoArrowFunction(obj, cubeName, obj, errorsReport);
           } else if (Array.isArray(obj)) {
@@ -274,9 +273,9 @@ export class YamlCompiler {
     return result.join('');
   }
 
-  private parsePythonIntoArrowFunction(codeString: string, cubeName, originalObj, errorsReport: ErrorReporter, ensureCubeParam = false) {
+  private parsePythonIntoArrowFunction(codeString: string, cubeName, originalObj, errorsReport: ErrorReporter) {
     const ast = this.parsePythonAndTranspileToJs(codeString, errorsReport);
-    return this.astIntoArrowFunction(ast as any, codeString, cubeName, undefined, ensureCubeParam);
+    return this.astIntoArrowFunction(ast as any, codeString, cubeName);
   }
 
   private parsePythonAndTranspileToJs(codeString: string, errorsReport: ErrorReporter): t.Program | t.NullLiteral {
@@ -294,7 +293,7 @@ export class YamlCompiler {
     return t.nullLiteral();
   }
 
-  private astIntoArrowFunction(input: t.Program | t.NullLiteral, codeString: string, cubeName, resolveSymbol?: (string) => any, ensureCubeParam = false) {
+  private astIntoArrowFunction(input: t.Program | t.NullLiteral, codeString: string, cubeName, resolveSymbol?: (string) => any) {
     const initialJs = babelGenerator(input, {}, codeString).code;
 
     // Re-parse generated JS to set all necessary parent paths
@@ -312,7 +311,7 @@ export class YamlCompiler {
 
     const traverseObj = {
       Program: (babelPath) => {
-        CubePropContextTranspiler.replaceValueWithArrowFunction(<(string) => any>resolveSymbol, babelPath.get('body')[0].get('expression'), ensureCubeParam);
+        CubePropContextTranspiler.replaceValueWithArrowFunction(<(string) => any>resolveSymbol, babelPath.get('body')[0].get('expression'));
       },
     };
 

packages/cubejs-schema-compiler/src/compiler/transpilers/CubePropContextTranspiler.ts

@@ -37,8 +37,6 @@ export const transpiledFieldsPatterns: Array<RegExp> = [
   /^(measures|dimensions)\.[_a-zA-Z][_a-zA-Z0-9]*\.mask\.sql$/,
 ];
 
-const maskSqlPattern = /^(measures|dimensions)\.[_a-zA-Z][_a-zA-Z0-9]*\.mask\.sql$/;
-
 export const transpiledFields: Set<String> = new Set<String>();
 
 transpiledFieldsPatterns?.forEach((r) => {
@@ -78,11 +76,11 @@ export class CubePropContextTranspiler implements TranspilerInterface {
     };
   }
 
-  protected transformObjectProperty(path: NodePath<t.ObjectProperty>, resolveSymbol: SymbolResolver, ensureCubeParam = false) {
-    CubePropContextTranspiler.replaceValueWithArrowFunction(resolveSymbol, path.get('value'), ensureCubeParam);
+  protected transformObjectProperty(path: NodePath<t.ObjectProperty>, resolveSymbol: SymbolResolver) {
+    CubePropContextTranspiler.replaceValueWithArrowFunction(resolveSymbol, path.get('value'));
   }
 
-  public static replaceValueWithArrowFunction(resolveSymbol: (name: string) => any, value: NodePath<any>, ensureCubeParam = false) {
+  public static replaceValueWithArrowFunction(resolveSymbol: (name: string) => any, value: NodePath<any>) {
     // If the current value is already an arrow function, update its parameters and keep the body
     if (t.isArrowFunctionExpression(value.node)) {
       const bodyPath = value.get('body') as NodePath<any>;
@@ -91,10 +89,6 @@ export class CubePropContextTranspiler implements TranspilerInterface {
         bodyPath,
       );
 
-      if (ensureCubeParam && !knownIds.includes('CUBE')) {
-        knownIds.push('CUBE');
-      }
-
       value.replaceWith(
         t.arrowFunctionExpression(
           knownIds.map(i => t.identifier(i)),
@@ -108,10 +102,6 @@ export class CubePropContextTranspiler implements TranspilerInterface {
         value,
       );
 
-      if (ensureCubeParam && !knownIds.includes('CUBE')) {
-        knownIds.push('CUBE');
-      }
-
       value.replaceWith(
         t.arrowFunctionExpression(
           knownIds.map(i => t.identifier(i)),
@@ -145,8 +135,7 @@ export class CubePropContextTranspiler implements TranspilerInterface {
           // eslint-disable-next-line no-restricted-syntax
           for (const p of transpiledFieldsPatterns) {
             if (fullPath.match(p)) {
-              const isMaskSql = maskSqlPattern.test(fullPath);
-              this.transformObjectProperty(path, resolveSymbol, isMaskSql);
+              this.transformObjectProperty(path, resolveSymbol);
               return;
             }
           }

packages/cubejs-schema-compiler/test/unit/transpilers.test.ts

@@ -379,32 +379,6 @@ describe('Transpilers', () => {
     expect(transpiledMaskSql!.toString()).toMatch('SECURITY_CONTEXT.cubeCloud.userAttributes');
   });
 
-  it('CubePropContextTranspiler mask.sql should always have CUBE as default parameter', async () => {
-    const { cubeEvaluator, compiler } = prepareJsCompiler(`
-        cube(\`Test\`, {
-          sql: 'SELECT * FROM users',
-          dimensions: {
-            userId: {
-              sql: \`userId\`,
-              type: 'string'
-            },
-            masked_dim: {
-              sql: \`price\`,
-              type: 'number',
-              mask: {
-                sql: \`-1\`,
-              }
-            }
-          }
-        })
-    `);
-
-    await compiler.compile();
-
-    const transpiledMaskSql = (cubeEvaluator.cubeFromPath('Test').dimensions.masked_dim as any).mask.sql;
-    expect(transpiledMaskSql!.toString()).toMatch('CUBE');
-  });
-
   it('CubePropContextTranspiler mask.sql with CUBE reference should resolve correctly', async () => {
     const compilers = prepareJsCompiler(`
         cube(\`Test\`, {