@devrev/meerkat-browser 0.0.84 → 0.0.85

package/package.json

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

package/src/ast/dimension.d.ts

@@ -0,0 +1,12 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+/**
+ * Validates the query can be used as a dimension by parsing it to an AST and checking its structure
+ * @param connection - DuckDB connection instance
+ * @param query - The query string to validate
+ * @returns Promise<boolean> - Whether the dimension is valid
+ */
+export declare const validateDimensionQuery: ({ connection, query, validFunctions, }: {
+    connection: AsyncDuckDBConnection;
+    query: string;
+    validFunctions?: string[] | undefined;
+}) => Promise<boolean>;

package/src/ast/dimension.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "validateDimensionQuery", {
+    enumerable: true,
+    get: function() {
+        return validateDimensionQuery;
+    }
+});
+const _meerkatcore = require("@devrev/meerkat-core");
+const _querytoast = require("./query-to-ast");
+const _utils = require("./utils");
+const validateDimensionQuery = async ({ connection, query, validFunctions })=>{
+    const parsedSerialization = await (0, _querytoast.parseQueryToAST)(query, connection);
+    if ((0, _utils.isParseError)(parsedSerialization)) {
+        var _parsedSerialization_error_message;
+        throw new Error((_parsedSerialization_error_message = parsedSerialization.error_message) != null ? _parsedSerialization_error_message : 'Unknown error');
+    }
+    // Only fetch valid functions if not provided
+    const availableFunctions = validFunctions != null ? validFunctions : await (0, _utils.getAvailableFunctions)(connection, 'scalar');
+    return (0, _meerkatcore.validateDimension)(parsedSerialization, availableFunctions);
+};
+
+//# sourceMappingURL=dimension.js.map

package/src/ast/dimension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-browser/src/ast/dimension.ts"],"sourcesContent":["import { validateDimension } from '@devrev/meerkat-core';\nimport { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';\nimport { parseQueryToAST } from './query-to-ast';\nimport { getAvailableFunctions, isParseError } from './utils';\n\n/**\n * Validates the query can be used as a dimension by parsing it to an AST and checking its structure\n * @param connection - DuckDB connection instance\n * @param query - The query string to validate\n * @returns Promise<boolean> - Whether the dimension is valid\n */\nexport const validateDimensionQuery = async ({\n  connection,\n  query,\n  validFunctions,\n}: {\n  connection: AsyncDuckDBConnection;\n  query: string;\n  validFunctions?: string[];\n}): Promise<boolean> => {\n  const parsedSerialization = await parseQueryToAST(query, connection);\n\n  if (isParseError(parsedSerialization)) {\n    throw new Error(parsedSerialization.error_message ?? 'Unknown error');\n  }\n\n  // Only fetch valid functions if not provided\n  const availableFunctions =\n    validFunctions ?? (await getAvailableFunctions(connection, 'scalar'));\n\n  return validateDimension(parsedSerialization, availableFunctions);\n};\n"],"names":["validateDimensionQuery","connection","query","validFunctions","parsedSerialization","parseQueryToAST","isParseError","Error","error_message","availableFunctions","getAvailableFunctions","validateDimension"],"mappings":";+BAWaA;;;eAAAA;;;6BAXqB;4BAEF;uBACoB;AAQ7C,MAAMA,yBAAyB,OAAO,EAC3CC,UAAU,EACVC,KAAK,EACLC,cAAc,EAKf;IACC,MAAMC,sBAAsB,MAAMC,IAAAA,2BAAe,EAACH,OAAOD;IAEzD,IAAIK,IAAAA,mBAAY,EAACF,sBAAsB;YACrBA;QAAhB,MAAM,IAAIG,MAAMH,CAAAA,qCAAAA,oBAAoBI,aAAa,YAAjCJ,qCAAqC;IACvD;IAEA,6CAA6C;IAC7C,MAAMK,qBACJN,yBAAAA,iBAAmB,MAAMO,IAAAA,4BAAqB,EAACT,YAAY;IAE7D,OAAOU,IAAAA,8BAAiB,EAACP,qBAAqBK;AAChD"}

package/src/ast/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dimension';
+export * from './measure';
+export * from './query-to-ast';

package/src/ast/index.js

@@ -0,0 +1,7 @@
+"use strict";
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./dimension"), exports);
+_export_star._(require("./measure"), exports);
+_export_star._(require("./query-to-ast"), exports);
+
+//# sourceMappingURL=index.js.map

package/src/ast/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-browser/src/ast/index.ts"],"sourcesContent":["export * from './dimension';\nexport * from './measure';\nexport * from './query-to-ast';\n"],"names":[],"mappings":";;uBAAc;uBACA;uBACA"}

package/src/ast/measure.d.ts

@@ -0,0 +1,12 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+/**
+ * Validates the query can be used as a measure by parsing it to an AST and checking its structure
+ * @param connection - DuckDB connection instance
+ * @param query - The query string to validate
+ * @returns Promise<boolean> - Whether the measure is valid
+ */
+export declare const validateMeasureQuery: ({ connection, query, validFunctions, }: {
+    connection: AsyncDuckDBConnection;
+    query: string;
+    validFunctions?: string[] | undefined;
+}) => Promise<boolean>;

package/src/ast/measure.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "validateMeasureQuery", {
+    enumerable: true,
+    get: function() {
+        return validateMeasureQuery;
+    }
+});
+const _meerkatcore = require("@devrev/meerkat-core");
+const _querytoast = require("./query-to-ast");
+const _utils = require("./utils");
+const validateMeasureQuery = async ({ connection, query, validFunctions })=>{
+    const parsedSerialization = await (0, _querytoast.parseQueryToAST)(query, connection);
+    if ((0, _utils.isParseError)(parsedSerialization)) {
+        var _parsedSerialization_error_message;
+        throw new Error((_parsedSerialization_error_message = parsedSerialization.error_message) != null ? _parsedSerialization_error_message : 'Unknown error');
+    }
+    // Only fetch valid functions if not provided
+    const availableFunctions = validFunctions != null ? validFunctions : await (0, _utils.getAvailableFunctions)(connection, 'aggregate');
+    const validScalarFunctions = await (0, _utils.getAvailableFunctions)(connection, 'scalar');
+    return (0, _meerkatcore.validateMeasure)(parsedSerialization, availableFunctions, validScalarFunctions);
+};
+
+//# sourceMappingURL=measure.js.map

package/src/ast/measure.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-browser/src/ast/measure.ts"],"sourcesContent":["import { validateMeasure } from '@devrev/meerkat-core';\nimport { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';\nimport { parseQueryToAST } from './query-to-ast';\nimport { getAvailableFunctions, isParseError } from './utils';\n\n/**\n * Validates the query can be used as a measure by parsing it to an AST and checking its structure\n * @param connection - DuckDB connection instance\n * @param query - The query string to validate\n * @returns Promise<boolean> - Whether the measure is valid\n */\nexport const validateMeasureQuery = async ({\n  connection,\n  query,\n  validFunctions,\n}: {\n  connection: AsyncDuckDBConnection;\n  query: string;\n  validFunctions?: string[];\n}): Promise<boolean> => {\n  const parsedSerialization = await parseQueryToAST(query, connection);\n\n  if (isParseError(parsedSerialization)) {\n    throw new Error(parsedSerialization.error_message ?? 'Unknown error');\n  }\n\n  // Only fetch valid functions if not provided\n  const availableFunctions =\n    validFunctions ?? (await getAvailableFunctions(connection, 'aggregate'));\n\n  const validScalarFunctions = await getAvailableFunctions(\n    connection,\n    'scalar'\n  );\n\n  return validateMeasure(\n    parsedSerialization,\n    availableFunctions,\n    validScalarFunctions\n  );\n};\n"],"names":["validateMeasureQuery","connection","query","validFunctions","parsedSerialization","parseQueryToAST","isParseError","Error","error_message","availableFunctions","getAvailableFunctions","validScalarFunctions","validateMeasure"],"mappings":";+BAWaA;;;eAAAA;;;6BAXmB;4BAEA;uBACoB;AAQ7C,MAAMA,uBAAuB,OAAO,EACzCC,UAAU,EACVC,KAAK,EACLC,cAAc,EAKf;IACC,MAAMC,sBAAsB,MAAMC,IAAAA,2BAAe,EAACH,OAAOD;IAEzD,IAAIK,IAAAA,mBAAY,EAACF,sBAAsB;YACrBA;QAAhB,MAAM,IAAIG,MAAMH,CAAAA,qCAAAA,oBAAoBI,aAAa,YAAjCJ,qCAAqC;IACvD;IAEA,6CAA6C;IAC7C,MAAMK,qBACJN,yBAAAA,iBAAmB,MAAMO,IAAAA,4BAAqB,EAACT,YAAY;IAE7D,MAAMU,uBAAuB,MAAMD,IAAAA,4BAAqB,EACtDT,YACA;IAGF,OAAOW,IAAAA,4BAAe,EACpBR,qBACAK,oBACAE;AAEJ"}

package/src/ast/query-to-ast.d.ts

@@ -0,0 +1,9 @@
+import { ParsedSerialization } from '@devrev/meerkat-core';
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+/**
+ * Converts a query to an AST
+ * @param query - The query string to convert
+ * @param connection - The DuckDB connection instance
+ * @returns The AST as a JSON object
+ */
+export declare const parseQueryToAST: (query: string, connection: AsyncDuckDBConnection) => Promise<ParsedSerialization>;

package/src/ast/query-to-ast.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "parseQueryToAST", {
+    enumerable: true,
+    get: function() {
+        return parseQueryToAST;
+    }
+});
+const _meerkatcore = require("@devrev/meerkat-core");
+const parseQueryToAST = async (query, connection)=>{
+    try {
+        const serializedQuery = (0, _meerkatcore.astSerializerQuery)(query);
+        const arrowResult = await connection.query(serializedQuery);
+        const parsedOutputQuery = arrowResult.toArray().map((row)=>row.toJSON());
+        const deserializedQuery = (0, _meerkatcore.deserializeQuery)(parsedOutputQuery);
+        return JSON.parse(deserializedQuery);
+    } catch (error) {
+        throw new Error('Failed to parse query to AST');
+    }
+};
+
+//# sourceMappingURL=query-to-ast.js.map

package/src/ast/query-to-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-browser/src/ast/query-to-ast.ts"],"sourcesContent":["import {\n  astSerializerQuery,\n  deserializeQuery,\n  ParsedSerialization,\n} from '@devrev/meerkat-core';\nimport { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';\n\n/**\n * Converts a query to an AST\n * @param query - The query string to convert\n * @param connection - The DuckDB connection instance\n * @returns The AST as a JSON object\n */\nexport const parseQueryToAST = async (\n  query: string,\n  connection: AsyncDuckDBConnection\n): Promise<ParsedSerialization> => {\n  try {\n    const serializedQuery = astSerializerQuery(query);\n    const arrowResult = await connection.query(serializedQuery);\n\n    const parsedOutputQuery = arrowResult.toArray().map((row) => row.toJSON());\n    const deserializedQuery = deserializeQuery(parsedOutputQuery);\n\n    return JSON.parse(deserializedQuery);\n  } catch (error) {\n    throw new Error('Failed to parse query to AST');\n  }\n};\n"],"names":["parseQueryToAST","query","connection","serializedQuery","astSerializerQuery","arrowResult","parsedOutputQuery","toArray","map","row","toJSON","deserializedQuery","deserializeQuery","JSON","parse","error","Error"],"mappings":";+BAaaA;;;eAAAA;;;6BATN;AASA,MAAMA,kBAAkB,OAC7BC,OACAC;IAEA,IAAI;QACF,MAAMC,kBAAkBC,IAAAA,+BAAkB,EAACH;QAC3C,MAAMI,cAAc,MAAMH,WAAWD,KAAK,CAACE;QAE3C,MAAMG,oBAAoBD,YAAYE,OAAO,GAAGC,GAAG,CAAC,CAACC,MAAQA,IAAIC,MAAM;QACvE,MAAMC,oBAAoBC,IAAAA,6BAAgB,EAACN;QAE3C,OAAOO,KAAKC,KAAK,CAACH;IACpB,EAAE,OAAOI,OAAO;QACd,MAAM,IAAIC,MAAM;IAClB;AACF"}

package/src/ast/utils.d.ts

@@ -0,0 +1,4 @@
+import { ParsedSerialization } from '@devrev/meerkat-core';
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+export declare const isParseError: (data: ParsedSerialization) => boolean;
+export declare const getAvailableFunctions: (connection: AsyncDuckDBConnection, function_type: 'scalar' | 'aggregate') => Promise<string[]>;

package/src/ast/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isParseError: function() {
+        return isParseError;
+    },
+    getAvailableFunctions: function() {
+        return getAvailableFunctions;
+    }
+});
+const isParseError = (data)=>{
+    return !!data.error;
+};
+const getAvailableFunctions = async (connection, function_type)=>{
+    const result = await connection.query(`SELECT distinct function_name FROM duckdb_functions() WHERE function_type = '${function_type}'`);
+    return result.toArray().map((row)=>row.toJSON().function_name);
+};
+
+//# sourceMappingURL=utils.js.map

package/src/ast/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-browser/src/ast/utils.ts"],"sourcesContent":["import { ParsedSerialization } from '@devrev/meerkat-core';\nimport { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';\n\nexport const isParseError = (data: ParsedSerialization): boolean => {\n  return !!data.error;\n};\n\n// Helper function to get available functions from DuckDB based on function type\nexport const getAvailableFunctions = async (\n  connection: AsyncDuckDBConnection,\n  function_type: 'scalar' | 'aggregate'\n): Promise<string[]> => {\n  const result = await connection.query(\n    `SELECT distinct function_name FROM duckdb_functions() WHERE function_type = '${function_type}'`\n  );\n\n  return result.toArray().map((row) => row.toJSON().function_name);\n};\n"],"names":["isParseError","getAvailableFunctions","data","error","connection","function_type","result","query","toArray","map","row","toJSON","function_name"],"mappings":";;;;;;;;IAGaA,YAAY;eAAZA;;IAKAC,qBAAqB;eAArBA;;;AALN,MAAMD,eAAe,CAACE;IAC3B,OAAO,CAAC,CAACA,KAAKC,KAAK;AACrB;AAGO,MAAMF,wBAAwB,OACnCG,YACAC;IAEA,MAAMC,SAAS,MAAMF,WAAWG,KAAK,CACnC,CAAC,6EAA6E,EAAEF,cAAc,CAAC,CAAC;IAGlG,OAAOC,OAAOE,OAAO,GAAGC,GAAG,CAAC,CAACC,MAAQA,IAAIC,MAAM,GAAGC,aAAa;AACjE"}

package/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './browser-cube-to-sql/browser-cube-to-sql';
 export { convertCubeStringToTableSchema };
 import { convertCubeStringToTableSchema } from '@devrev/meerkat-core';
+export { parseQueryToAST, validateDimensionQuery, validateMeasureQuery, } from './ast';

package/src/index.js

@@ -1,12 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "convertCubeStringToTableSchema", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    convertCubeStringToTableSchema: function() {
         return _meerkatcore.convertCubeStringToTableSchema;
+    },
+    parseQueryToAST: function() {
+        return _ast.parseQueryToAST;
+    },
+    validateDimensionQuery: function() {
+        return _ast.validateDimensionQuery;
+    },
+    validateMeasureQuery: function() {
+        return _ast.validateMeasureQuery;
     }
 });
 const _export_star = require("@swc/helpers/_/_export_star");
 _export_star._(require("./browser-cube-to-sql/browser-cube-to-sql"), exports);
 const _meerkatcore = require("@devrev/meerkat-core");
+const _ast = require("./ast");
 
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-browser/src/index.ts"],"sourcesContent":["export * from './browser-cube-to-sql/browser-cube-to-sql';\nexport { convertCubeStringToTableSchema };\nimport { convertCubeStringToTableSchema } from '@devrev/meerkat-core';\n"],"names":["convertCubeStringToTableSchema"],"mappings":";+BACSA;;;eAAAA,2CAA8B;;;;uBADzB;6BAEiC"}
+{"version":3,"sources":["../../../meerkat-browser/src/index.ts"],"sourcesContent":["export * from './browser-cube-to-sql/browser-cube-to-sql';\nexport { convertCubeStringToTableSchema };\nimport { convertCubeStringToTableSchema } from '@devrev/meerkat-core';\nexport {\n  parseQueryToAST,\n  validateDimensionQuery,\n  validateMeasureQuery,\n} from './ast';\n"],"names":["convertCubeStringToTableSchema","parseQueryToAST","validateDimensionQuery","validateMeasureQuery"],"mappings":";;;;;;;;IACSA,8BAA8B;eAA9BA,2CAA8B;;IAGrCC,eAAe;eAAfA,oBAAe;;IACfC,sBAAsB;eAAtBA,2BAAsB;;IACtBC,oBAAoB;eAApBA,yBAAoB;;;;uBANR;6BAEiC;qBAKxC"}