@devrev/meerkat-core 0.0.84 → 0.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/meerkat-core",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "dependencies": {
     "@swc/helpers": "~0.5.0"
   },

package/src/ast-serializer/ast-serializer.d.ts

@@ -0,0 +1 @@
+export declare const astSerializerQuery: (query: string) => string;

package/src/ast-serializer/ast-serializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "astSerializerQuery", {
+    enumerable: true,
+    get: function() {
+        return astSerializerQuery;
+    }
+});
+const astSerializerQuery = (query)=>{
+    return `SELECT json_serialize_sql('${query}')`;
+};
+
+//# sourceMappingURL=ast-serializer.js.map

package/src/ast-serializer/ast-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/ast-serializer/ast-serializer.ts"],"sourcesContent":["export const astSerializerQuery = (query: string) => {\n  return `SELECT json_serialize_sql('${query}')`;\n};\n"],"names":["astSerializerQuery","query"],"mappings":";+BAAaA;;;eAAAA;;;AAAN,MAAMA,qBAAqB,CAACC;IACjC,OAAO,CAAC,2BAA2B,EAAEA,MAAM,EAAE,CAAC;AAChD"}

package/src/ast-validator/dimension-validator.d.ts

@@ -0,0 +1,10 @@
+import { ParsedExpression } from '../types/duckdb-serialization-types';
+import { ParsedSerialization } from './types';
+/**
+ * Validates an individual expression node
+ */
+export declare const validateExpressionNode: (node: ParsedExpression, validFunctions: Set<string>) => boolean;
+/**
+ * Validates if the parsed serialization represents a valid dimension
+ */
+export declare const validateDimension: (parsedSerialization: ParsedSerialization, validFunctions: string[]) => boolean;

package/src/ast-validator/dimension-validator.js

@@ -0,0 +1,54 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    validateExpressionNode: function() {
+        return validateExpressionNode;
+    },
+    validateDimension: function() {
+        return validateDimension;
+    }
+});
+const _utils = require("../types/utils");
+const _utils1 = require("./utils");
+const validateExpressionNode = (node, validFunctions)=>{
+    // Column references and value constants
+    if ((0, _utils.isColumnRefExpression)(node) || (0, _utils.isConstantExpression)(node)) {
+        return true;
+    }
+    // Cast expression
+    if ((0, _utils.isCastExpression)(node)) {
+        return validateExpressionNode(node.child, validFunctions);
+    }
+    // Operator expression
+    if ((0, _utils.isOperatorExpression)(node)) {
+        return node.children.every((child)=>validateExpressionNode(child, validFunctions));
+    }
+    // Function expression
+    if ((0, _utils.isFunctionExpression)(node)) {
+        if (!validFunctions.has(node.function_name)) {
+            throw new Error(`Invalid function: ${node.function_name}`);
+        }
+        return node.children.every((child)=>validateExpressionNode(child, validFunctions));
+    }
+    // Case expression
+    if ((0, _utils.isCaseExpression)(node)) {
+        return node.case_checks.every((check)=>validateExpressionNode(check.then_expr, validFunctions)) && validateExpressionNode(node.else_expr, validFunctions);
+    }
+    throw new Error(`Invalid expression type: ${node.type}`);
+};
+const validateDimension = (parsedSerialization, validFunctions)=>{
+    const node = (0, _utils1.getSelectNode)(parsedSerialization);
+    const validFunctionSet = new Set(validFunctions);
+    // Validate the expression
+    if (validateExpressionNode(node, validFunctionSet)) {
+        return true;
+    }
+    throw new Error('Expression contains invalid functions or operators');
+};
+
+//# sourceMappingURL=dimension-validator.js.map

package/src/ast-validator/dimension-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/ast-validator/dimension-validator.ts"],"sourcesContent":["import { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isCaseExpression,\n  isCastExpression,\n  isColumnRefExpression,\n  isConstantExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n} from '../types/utils';\nimport { ParsedSerialization } from './types';\nimport { getSelectNode } from './utils';\n\n/**\n * Validates an individual expression node\n */\nexport const validateExpressionNode = (\n  node: ParsedExpression,\n  validFunctions: Set<string>\n): boolean => {\n  // Column references and value constants\n  if (isColumnRefExpression(node) || isConstantExpression(node)) {\n    return true;\n  }\n\n  // Cast expression\n  if (isCastExpression(node)) {\n    return validateExpressionNode(node.child, validFunctions);\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.every((child) =>\n      validateExpressionNode(child, validFunctions)\n    );\n  }\n\n  // Function expression\n  if (isFunctionExpression(node)) {\n    if (!validFunctions.has(node.function_name)) {\n      throw new Error(`Invalid function: ${node.function_name}`);\n    }\n    return node.children.every((child) =>\n      validateExpressionNode(child, validFunctions)\n    );\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    return (\n      node.case_checks.every((check) =>\n        validateExpressionNode(check.then_expr, validFunctions)\n      ) && validateExpressionNode(node.else_expr, validFunctions)\n    );\n  }\n\n  throw new Error(`Invalid expression type: ${node.type}`);\n};\n\n/**\n * Validates if the parsed serialization represents a valid dimension\n */\nexport const validateDimension = (\n  parsedSerialization: ParsedSerialization,\n  validFunctions: string[]\n): boolean => {\n  const node = getSelectNode(parsedSerialization);\n\n  const validFunctionSet = new Set(validFunctions);\n\n  // Validate the expression\n  if (validateExpressionNode(node, validFunctionSet)) {\n    return true;\n  }\n\n  throw new Error('Expression contains invalid functions or operators');\n};\n"],"names":["validateExpressionNode","validateDimension","node","validFunctions","isColumnRefExpression","isConstantExpression","isCastExpression","child","isOperatorExpression","children","every","isFunctionExpression","has","function_name","Error","isCaseExpression","case_checks","check","then_expr","else_expr","type","parsedSerialization","getSelectNode","validFunctionSet","Set"],"mappings":";;;;;;;;IAeaA,sBAAsB;eAAtBA;;IA8CAC,iBAAiB;eAAjBA;;;uBArDN;wBAEuB;AAKvB,MAAMD,yBAAyB,CACpCE,MACAC;IAEA,wCAAwC;IACxC,IAAIC,IAAAA,4BAAqB,EAACF,SAASG,IAAAA,2BAAoB,EAACH,OAAO;QAC7D,OAAO;IACT;IAEA,kBAAkB;IAClB,IAAII,IAAAA,uBAAgB,EAACJ,OAAO;QAC1B,OAAOF,uBAAuBE,KAAKK,KAAK,EAAEJ;IAC5C;IAEA,sBAAsB;IACtB,IAAIK,IAAAA,2BAAoB,EAACN,OAAO;QAC9B,OAAOA,KAAKO,QAAQ,CAACC,KAAK,CAAC,CAACH,QAC1BP,uBAAuBO,OAAOJ;IAElC;IAEA,sBAAsB;IACtB,IAAIQ,IAAAA,2BAAoB,EAACT,OAAO;QAC9B,IAAI,CAACC,eAAeS,GAAG,CAACV,KAAKW,aAAa,GAAG;YAC3C,MAAM,IAAIC,MAAM,CAAC,kBAAkB,EAAEZ,KAAKW,aAAa,CAAC,CAAC;QAC3D;QACA,OAAOX,KAAKO,QAAQ,CAACC,KAAK,CAAC,CAACH,QAC1BP,uBAAuBO,OAAOJ;IAElC;IAEA,kBAAkB;IAClB,IAAIY,IAAAA,uBAAgB,EAACb,OAAO;QAC1B,OACEA,KAAKc,WAAW,CAACN,KAAK,CAAC,CAACO,QACtBjB,uBAAuBiB,MAAMC,SAAS,EAAEf,oBACrCH,uBAAuBE,KAAKiB,SAAS,EAAEhB;IAEhD;IAEA,MAAM,IAAIW,MAAM,CAAC,yBAAyB,EAAEZ,KAAKkB,IAAI,CAAC,CAAC;AACzD;AAKO,MAAMnB,oBAAoB,CAC/BoB,qBACAlB;IAEA,MAAMD,OAAOoB,IAAAA,qBAAa,EAACD;IAE3B,MAAME,mBAAmB,IAAIC,IAAIrB;IAEjC,0BAA0B;IAC1B,IAAIH,uBAAuBE,MAAMqB,mBAAmB;QAClD,OAAO;IACT;IAEA,MAAM,IAAIT,MAAM;AAClB"}

package/src/ast-validator/index.d.ts

@@ -0,0 +1,3 @@
+export { validateDimension } from './dimension-validator';
+export { validateMeasure } from './measure-validator';
+export * from './types';

package/src/ast-validator/index.js

@@ -0,0 +1,21 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    validateDimension: function() {
+        return _dimensionvalidator.validateDimension;
+    },
+    validateMeasure: function() {
+        return _measurevalidator.validateMeasure;
+    }
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+const _dimensionvalidator = require("./dimension-validator");
+const _measurevalidator = require("./measure-validator");
+_export_star._(require("./types"), exports);
+
+//# sourceMappingURL=index.js.map

package/src/ast-validator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/ast-validator/index.ts"],"sourcesContent":["export { validateDimension } from './dimension-validator';\nexport { validateMeasure } from './measure-validator';\nexport * from './types';\n"],"names":["validateDimension","validateMeasure"],"mappings":";;;;;;;;IAASA,iBAAiB;eAAjBA,qCAAiB;;IACjBC,eAAe;eAAfA,iCAAe;;;;oCADU;kCACF;uBAClB"}

package/src/ast-validator/measure-validator.d.ts

@@ -0,0 +1,11 @@
+import { ParsedExpression } from '../types/duckdb-serialization-types';
+import { ParsedSerialization } from './types';
+export declare const validateExpressionNode: ({ node, validFunctions, parentNode, validScalarFunctions, hasAggregation, }: {
+    node: ParsedExpression;
+    validFunctions: Set<string>;
+    parentNode: ParsedExpression | null;
+    hasAggregation?: boolean | undefined;
+    validScalarFunctions: Set<string>;
+}) => boolean;
+export declare const containsAggregation: (node: ParsedExpression, validFunctions: Set<string>) => boolean;
+export declare const validateMeasure: (parsedSerialization: ParsedSerialization, validFunctions: string[], validScalarFunctions: string[]) => boolean;

package/src/ast-validator/measure-validator.js

@@ -0,0 +1,162 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    validateExpressionNode: function() {
+        return validateExpressionNode;
+    },
+    containsAggregation: function() {
+        return containsAggregation;
+    },
+    validateMeasure: function() {
+        return validateMeasure;
+    }
+});
+const _utils = require("../types/utils");
+const _utils1 = require("./utils");
+const validateExpressionNode = ({ node, validFunctions, parentNode, validScalarFunctions, hasAggregation = false })=>{
+    // Base cases for column references and constants
+    if ((0, _utils.isColumnRefExpression)(node) || (0, _utils.isConstantExpression)(node)) {
+        // Allow column references inside aggregation functions
+        return !!parentNode;
+    }
+    // Check for valid aggregation functions
+    if ((0, _utils.isFunctionExpression)(node) || (0, _utils.isWindowExpression)(node)) {
+        // count_star don't have children
+        if (node.function_name === 'count_star') return true;
+        // This is a valid aggregation function - verify its children don't contain nested aggregations
+        if (validFunctions.has(node.function_name)) {
+            return node.children.some((child)=>validateExpressionNode({
+                    node: child,
+                    validFunctions,
+                    parentNode: node,
+                    validScalarFunctions
+                }));
+        }
+        // For non-aggregation functions
+        if (validScalarFunctions.has(node.function_name)) {
+            return node.children.some((child)=>{
+                return validateExpressionNode({
+                    node: child,
+                    validFunctions,
+                    parentNode: node,
+                    validScalarFunctions
+                }) && (containsAggregation(child, validFunctions) || hasAggregation);
+            });
+        }
+        throw new Error(`Invalid function type: ${node.function_name}`);
+    }
+    // Operator expression
+    if ((0, _utils.isOperatorExpression)(node)) {
+        return node.children.some((child)=>validateExpressionNode({
+                node: child,
+                validFunctions,
+                parentNode,
+                validScalarFunctions
+            }));
+    }
+    // Cast expression
+    if ((0, _utils.isCastExpression)(node)) {
+        return validateExpressionNode({
+            node: node.child,
+            validFunctions,
+            parentNode,
+            validScalarFunctions
+        });
+    }
+    // Case expression
+    if ((0, _utils.isCaseExpression)(node)) {
+        const checksValid = node.case_checks.every((caseCheck)=>{
+            // WHEN conditions cannot contain aggregations
+            const whenValid = !containsAggregation(caseCheck.when_expr, validFunctions);
+            // THEN expressions must be valid aggregations or contain no aggregations
+            const thenValid = validateExpressionNode({
+                node: caseCheck.then_expr,
+                validFunctions,
+                parentNode: node,
+                validScalarFunctions
+            }) || !containsAggregation(caseCheck.then_expr, validFunctions);
+            return whenValid && thenValid;
+        });
+        const elseValid = validateExpressionNode({
+            node: node.else_expr,
+            validFunctions,
+            parentNode: node,
+            validScalarFunctions
+        }) || !containsAggregation(node.else_expr, validFunctions);
+        return checksValid && elseValid;
+    }
+    // Subquery expression
+    if ((0, _utils.isSubqueryExpression)(node) && (0, _utils.isSelectNode)(node.subquery.node)) {
+        return node.subquery.node.select_list.every((node)=>{
+            return validateExpressionNode({
+                node,
+                validFunctions,
+                parentNode,
+                validScalarFunctions
+            });
+        });
+    }
+    // Window expression
+    if ((0, _utils.isWindowExpression)(node)) {
+        return node.children.every((node)=>{
+            return validateExpressionNode({
+                node,
+                validFunctions,
+                parentNode,
+                validScalarFunctions
+            });
+        });
+    }
+    throw new Error(`Invalid expression type: ${node.type}`);
+};
+const containsAggregation = (node, validFunctions)=>{
+    if (!node) return false;
+    // Function expression
+    if ((0, _utils.isFunctionExpression)(node) || (0, _utils.isWindowExpression)(node)) {
+        return validFunctions.has(node.function_name) || node.children.some((child)=>containsAggregation(child, validFunctions));
+    }
+    // Case expression
+    if ((0, _utils.isCaseExpression)(node)) {
+        return node.case_checks.some((check)=>containsAggregation(check.when_expr, validFunctions) || containsAggregation(check.then_expr, validFunctions)) || containsAggregation(node.else_expr, validFunctions);
+    }
+    // Operator expression
+    if ((0, _utils.isOperatorExpression)(node)) {
+        return node.children.some((child)=>containsAggregation(child, validFunctions));
+    }
+    if ((0, _utils.isCastExpression)(node)) {
+        return containsAggregation(node.child, validFunctions);
+    }
+    // Window expression
+    if ((0, _utils.isWindowExpression)(node)) {
+        return node.children.some((child)=>containsAggregation(child, validFunctions));
+    }
+    // Subquery expression
+    if ((0, _utils.isSubqueryExpression)(node) && (0, _utils.isSelectNode)(node.subquery.node)) {
+        return node.subquery.node.select_list.every((node)=>{
+            return containsAggregation(node, validFunctions);
+        });
+    }
+    return false;
+};
+const validateMeasure = (parsedSerialization, validFunctions, validScalarFunctions)=>{
+    const node = (0, _utils1.getSelectNode)(parsedSerialization);
+    const validFunctionSet = new Set(validFunctions);
+    const validScalarFunctionSet = new Set(validScalarFunctions);
+    // Validate the expression
+    if (validateExpressionNode({
+        node: node,
+        validFunctions: validFunctionSet,
+        parentNode: null,
+        validScalarFunctions: validScalarFunctionSet
+    })) {
+        return true;
+    }
+    throw new Error('Expression contains invalid functions or operators');
+};
+
+//# sourceMappingURL=measure-validator.js.map

package/src/ast-validator/measure-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/ast-validator/measure-validator.ts"],"sourcesContent":["import { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isCaseExpression,\n  isCastExpression,\n  isColumnRefExpression,\n  isConstantExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n  isSelectNode,\n  isSubqueryExpression,\n  isWindowExpression,\n} from '../types/utils';\nimport { ParsedSerialization } from './types';\nimport { getSelectNode } from './utils';\n\nexport const validateExpressionNode = ({\n  node,\n  validFunctions,\n  parentNode,\n  validScalarFunctions,\n  hasAggregation = false,\n}: {\n  node: ParsedExpression;\n  validFunctions: Set<string>;\n  parentNode: ParsedExpression | null;\n  hasAggregation?: boolean;\n  validScalarFunctions: Set<string>;\n}): boolean => {\n  // Base cases for column references and constants\n  if (isColumnRefExpression(node) || isConstantExpression(node)) {\n    // Allow column references inside aggregation functions\n    return !!parentNode;\n  }\n\n  // Check for valid aggregation functions\n  if (isFunctionExpression(node) || isWindowExpression(node)) {\n    // count_star don't have children\n    if (node.function_name === 'count_star') return true;\n\n    // This is a valid aggregation function - verify its children don't contain nested aggregations\n    if (validFunctions.has(node.function_name)) {\n      return node.children.some((child) =>\n        validateExpressionNode({\n          node: child,\n          validFunctions,\n          parentNode: node,\n          validScalarFunctions,\n        })\n      );\n    }\n    // For non-aggregation functions\n    if (validScalarFunctions.has(node.function_name)) {\n      return node.children.some((child) => {\n        return (\n          validateExpressionNode({\n            node: child,\n            validFunctions,\n            parentNode: node,\n            validScalarFunctions,\n          }) &&\n          (containsAggregation(child, validFunctions) || hasAggregation)\n        );\n      });\n    }\n\n    throw new Error(`Invalid function type: ${node.function_name}`);\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.some((child) =>\n      validateExpressionNode({\n        node: child,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      })\n    );\n  }\n\n  // Cast expression\n  if (isCastExpression(node)) {\n    return validateExpressionNode({\n      node: node.child,\n      validFunctions,\n      parentNode,\n      validScalarFunctions,\n    });\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    const checksValid = node.case_checks.every((caseCheck) => {\n      // WHEN conditions cannot contain aggregations\n      const whenValid = !containsAggregation(\n        caseCheck.when_expr,\n        validFunctions\n      );\n\n      // THEN expressions must be valid aggregations or contain no aggregations\n      const thenValid =\n        validateExpressionNode({\n          node: caseCheck.then_expr,\n          validFunctions,\n          parentNode: node,\n          validScalarFunctions,\n        }) || !containsAggregation(caseCheck.then_expr, validFunctions);\n      return whenValid && thenValid;\n    });\n\n    const elseValid =\n      validateExpressionNode({\n        node: node.else_expr,\n        validFunctions,\n        parentNode: node,\n        validScalarFunctions,\n      }) || !containsAggregation(node.else_expr, validFunctions);\n\n    return checksValid && elseValid;\n  }\n\n  // Subquery expression\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    return node.subquery.node.select_list.every((node) => {\n      return validateExpressionNode({\n        node,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      });\n    });\n  }\n\n  // Window expression\n  if (isWindowExpression(node)) {\n    return node.children.every((node) => {\n      return validateExpressionNode({\n        node,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      });\n    });\n  }\n\n  throw new Error(`Invalid expression type: ${node.type}`);\n};\n\nexport const containsAggregation = (\n  node: ParsedExpression,\n  validFunctions: Set<string>\n): boolean => {\n  if (!node) return false;\n\n  // Function expression\n  if (isFunctionExpression(node) || isWindowExpression(node)) {\n    return (\n      validFunctions.has(node.function_name) ||\n      node.children.some((child) => containsAggregation(child, validFunctions))\n    );\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    return (\n      node.case_checks.some(\n        (check) =>\n          containsAggregation(check.when_expr, validFunctions) ||\n          containsAggregation(check.then_expr, validFunctions)\n      ) || containsAggregation(node.else_expr, validFunctions)\n    );\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.some((child) =>\n      containsAggregation(child, validFunctions)\n    );\n  }\n\n  if (isCastExpression(node)) {\n    return containsAggregation(node.child, validFunctions);\n  }\n\n  // Window expression\n  if (isWindowExpression(node)) {\n    return node.children.some((child) =>\n      containsAggregation(child, validFunctions)\n    );\n  }\n\n  // Subquery expression\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    return node.subquery.node.select_list.every((node) => {\n      return containsAggregation(node, validFunctions);\n    });\n  }\n\n  return false;\n};\n\nexport const validateMeasure = (\n  parsedSerialization: ParsedSerialization,\n  validFunctions: string[],\n  validScalarFunctions: string[]\n): boolean => {\n  const node = getSelectNode(parsedSerialization);\n\n  const validFunctionSet = new Set(validFunctions);\n  const validScalarFunctionSet = new Set(validScalarFunctions);\n\n  // Validate the expression\n  if (\n    validateExpressionNode({\n      node: node,\n      validFunctions: validFunctionSet,\n      parentNode: null,\n      validScalarFunctions: validScalarFunctionSet,\n    })\n  ) {\n    return true;\n  }\n\n  throw new Error('Expression contains invalid functions or operators');\n};\n"],"names":["validateExpressionNode","containsAggregation","validateMeasure","node","validFunctions","parentNode","validScalarFunctions","hasAggregation","isColumnRefExpression","isConstantExpression","isFunctionExpression","isWindowExpression","function_name","has","children","some","child","Error","isOperatorExpression","isCastExpression","isCaseExpression","checksValid","case_checks","every","caseCheck","whenValid","when_expr","thenValid","then_expr","elseValid","else_expr","isSubqueryExpression","isSelectNode","subquery","select_list","type","check","parsedSerialization","getSelectNode","validFunctionSet","Set","validScalarFunctionSet"],"mappings":"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"}