@devrev/meerkat-node 0.0.88 → 0.0.89

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@devrev/meerkat-node",
-  "version": "0.0.88",
+  "version": "0.0.89",
   "dependencies": {
     "@swc/helpers": "~0.5.0",
     "@devrev/meerkat-core": "*",
-    "duckdb": "^0.10.2"
+    "@duckdb/node-api": "1.1.3-alpha.7",
+    "axios": "^1.6.0",
+    "lodash": "^4.17.21"
   },
   "scripts": {
     "release": "semantic-release"

package/src/cube-to-sql/cube-to-sql.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../meerkat-node/src/cube-to-sql/cube-to-sql.ts"],"sourcesContent":["import {\n  BASE_TABLE_NAME,\n  ContextParams,\n  Query,\n  TableSchema,\n  applyFilterParamsToBaseSQL,\n  applyProjectionToSQLQuery,\n  astDeserializerQuery,\n  cubeToDuckdbAST,\n  deserializeQuery,\n  detectApplyContextParamsToBaseSQL,\n  getCombinedTableSchema,\n  getFilterParamsSQL,\n  getFinalBaseSQL\n} from '@devrev/meerkat-core';\nimport { duckdbExec } from '../duckdb-exec';\n\n\n\ninterface CubeQueryToSQLParams {\n  query: Query,\n  tableSchemas: TableSchema[],\n  contextParams?: ContextParams\n}\n\nexport const cubeQueryToSQL = async ({\n  query,\n  tableSchemas,\n  contextParams,\n}: CubeQueryToSQLParams) => {\n  const updatedTableSchemas: TableSchema[] = await Promise.all(\n    tableSchemas.map(async (schema: TableSchema) => {\n      const baseFilterParamsSQL = await getFinalBaseSQL({query, tableSchema: schema, getQueryOutput: duckdbExec });\n      return {\n        ...schema,\n        sql: baseFilterParamsSQL,\n      };\n    })\n  );\n\n  const updatedTableSchema = await getCombinedTableSchema(\n    updatedTableSchemas,\n    query\n  );\n\n  const ast = cubeToDuckdbAST(query, updatedTableSchema);\n  if (!ast) {\n    throw new Error('Could not generate AST');\n  }\n\n  const queryTemp = astDeserializerQuery(ast);\n\n  const queryOutput = await duckdbExec<\n    {\n      [key: string]: string;\n    }[]\n  >(queryTemp);\n  const preBaseQuery = deserializeQuery(queryOutput);\n\n  const filterParamsSQL = await getFilterParamsSQL({\n    query,\n    tableSchema: updatedTableSchema,\n    getQueryOutput: duckdbExec,\n  });\n\n  const filterParamQuery = applyFilterParamsToBaseSQL(\n    updatedTableSchema.sql,\n    filterParamsSQL\n  );\n\n  /**\n   * Replace CONTEXT_PARAMS with context params\n   */\n  const baseQuery = detectApplyContextParamsToBaseSQL(\n    filterParamQuery,\n    contextParams || {}\n  );\n\n  /**\n   * Replace BASE_TABLE_NAME with cube query\n   */\n  const replaceBaseTableName = preBaseQuery.replace(\n    BASE_TABLE_NAME,\n    `(${baseQuery}) AS ${updatedTableSchema.name}`\n  );\n\n  /**\n   * Add measures to the query\n   */\n  const measures = query.measures;\n  const dimensions = query.dimensions || [];\n  const finalQuery = applyProjectionToSQLQuery(\n    dimensions,\n    measures,\n    updatedTableSchema,\n    replaceBaseTableName\n  );\n\n  return finalQuery;\n};\n"],"names":["cubeQueryToSQL","query","tableSchemas","contextParams","updatedTableSchemas","Promise","all","map","schema","baseFilterParamsSQL","getFinalBaseSQL","tableSchema","getQueryOutput","duckdbExec","sql","updatedTableSchema","getCombinedTableSchema","ast","cubeToDuckdbAST","Error","queryTemp","astDeserializerQuery","queryOutput","preBaseQuery","deserializeQuery","filterParamsSQL","getFilterParamsSQL","filterParamQuery","applyFilterParamsToBaseSQL","baseQuery","detectApplyContextParamsToBaseSQL","replaceBaseTableName","replace","BASE_TABLE_NAME","name","measures","dimensions","finalQuery","applyProjectionToSQLQuery"],"mappings":";+BAyBaA;;;eAAAA;;;;6BAXN;4BACoB;AAUpB,MAAMA,iBAAiB,OAAO,EACnCC,KAAK,EACLC,YAAY,EACZC,aAAa,EACQ;IACrB,MAAMC,sBAAqC,MAAMC,QAAQC,GAAG,CAC1DJ,aAAaK,GAAG,CAAC,OAAOC;QACtB,MAAMC,sBAAsB,MAAMC,IAAAA,4BAAe,EAAC;YAACT;YAAOU,aAAaH;YAAQI,gBAAgBC,sBAAU;QAAC;QAC1G,OAAO,eACFL;YACHM,KAAKL;;IAET;IAGF,MAAMM,qBAAqB,MAAMC,IAAAA,mCAAsB,EACrDZ,qBACAH;IAGF,MAAMgB,MAAMC,IAAAA,4BAAe,EAACjB,OAAOc;IACnC,IAAI,CAACE,KAAK;QACR,MAAM,IAAIE,MAAM;IAClB;IAEA,MAAMC,YAAYC,IAAAA,iCAAoB,EAACJ;IAEvC,MAAMK,cAAc,MAAMT,IAAAA,sBAAU,EAIlCO;IACF,MAAMG,eAAeC,IAAAA,6BAAgB,EAACF;IAEtC,MAAMG,kBAAkB,MAAMC,IAAAA,+BAAkB,EAAC;QAC/CzB;QACAU,aAAaI;QACbH,gBAAgBC,sBAAU;IAC5B;IAEA,MAAMc,mBAAmBC,IAAAA,uCAA0B,EACjDb,mBAAmBD,GAAG,EACtBW;IAGF;;GAEC,GACD,MAAMI,YAAYC,IAAAA,8CAAiC,EACjDH,kBACAxB,iBAAiB,CAAC;IAGpB;;GAEC,GACD,MAAM4B,uBAAuBR,aAAaS,OAAO,CAC/CC,4BAAe,EACf,CAAC,CAAC,EAAEJ,UAAU,KAAK,EAAEd,mBAAmBmB,IAAI,CAAC,CAAC;IAGhD;;GAEC,GACD,MAAMC,WAAWlC,MAAMkC,QAAQ;IAC/B,MAAMC,aAAanC,MAAMmC,UAAU,IAAI,EAAE;IACzC,MAAMC,aAAaC,IAAAA,sCAAyB,EAC1CF,YACAD,UACApB,oBACAgB;IAGF,OAAOM;AACT"}
+{"version":3,"sources":["../../../../meerkat-node/src/cube-to-sql/cube-to-sql.ts"],"sourcesContent":["import {\n  BASE_TABLE_NAME,\n  ContextParams,\n  Query,\n  TableSchema,\n  applyFilterParamsToBaseSQL,\n  applyProjectionToSQLQuery,\n  astDeserializerQuery,\n  cubeToDuckdbAST,\n  deserializeQuery,\n  detectApplyContextParamsToBaseSQL,\n  getCombinedTableSchema,\n  getFilterParamsSQL,\n  getFinalBaseSQL,\n} from '@devrev/meerkat-core';\nimport { duckdbExec } from '../duckdb-exec';\n\ninterface CubeQueryToSQLParams {\n  query: Query;\n  tableSchemas: TableSchema[];\n  contextParams?: ContextParams;\n}\n\nexport const cubeQueryToSQL = async ({\n  query,\n  tableSchemas,\n  contextParams,\n}: CubeQueryToSQLParams) => {\n  const updatedTableSchemas: TableSchema[] = await Promise.all(\n    tableSchemas.map(async (schema: TableSchema) => {\n      const baseFilterParamsSQL = await getFinalBaseSQL({\n        query,\n        tableSchema: schema,\n        getQueryOutput: duckdbExec,\n      });\n      return {\n        ...schema,\n        sql: baseFilterParamsSQL,\n      };\n    })\n  );\n\n  const updatedTableSchema = await getCombinedTableSchema(\n    updatedTableSchemas,\n    query\n  );\n\n  const ast = cubeToDuckdbAST(query, updatedTableSchema);\n  if (!ast) {\n    throw new Error('Could not generate AST');\n  }\n\n  const queryTemp = astDeserializerQuery(ast);\n\n  const queryOutput = (await duckdbExec(queryTemp)) as Record<string, string>[];\n  const preBaseQuery = deserializeQuery(queryOutput);\n\n  const filterParamsSQL = await getFilterParamsSQL({\n    query,\n    tableSchema: updatedTableSchema,\n    getQueryOutput: duckdbExec,\n  });\n\n  const filterParamQuery = applyFilterParamsToBaseSQL(\n    updatedTableSchema.sql,\n    filterParamsSQL\n  );\n\n  /**\n   * Replace CONTEXT_PARAMS with context params\n   */\n  const baseQuery = detectApplyContextParamsToBaseSQL(\n    filterParamQuery,\n    contextParams || {}\n  );\n\n  /**\n   * Replace BASE_TABLE_NAME with cube query\n   */\n  const replaceBaseTableName = preBaseQuery.replace(\n    BASE_TABLE_NAME,\n    `(${baseQuery}) AS ${updatedTableSchema.name}`\n  );\n\n  /**\n   * Add measures to the query\n   */\n  const measures = query.measures;\n  const dimensions = query.dimensions || [];\n  const finalQuery = applyProjectionToSQLQuery(\n    dimensions,\n    measures,\n    updatedTableSchema,\n    replaceBaseTableName\n  );\n\n  return finalQuery;\n};\n"],"names":["cubeQueryToSQL","query","tableSchemas","contextParams","updatedTableSchemas","Promise","all","map","schema","baseFilterParamsSQL","getFinalBaseSQL","tableSchema","getQueryOutput","duckdbExec","sql","updatedTableSchema","getCombinedTableSchema","ast","cubeToDuckdbAST","Error","queryTemp","astDeserializerQuery","queryOutput","preBaseQuery","deserializeQuery","filterParamsSQL","getFilterParamsSQL","filterParamQuery","applyFilterParamsToBaseSQL","baseQuery","detectApplyContextParamsToBaseSQL","replaceBaseTableName","replace","BASE_TABLE_NAME","name","measures","dimensions","finalQuery","applyProjectionToSQLQuery"],"mappings":";+BAuBaA;;;eAAAA;;;;6BATN;4BACoB;AAQpB,MAAMA,iBAAiB,OAAO,EACnCC,KAAK,EACLC,YAAY,EACZC,aAAa,EACQ;IACrB,MAAMC,sBAAqC,MAAMC,QAAQC,GAAG,CAC1DJ,aAAaK,GAAG,CAAC,OAAOC;QACtB,MAAMC,sBAAsB,MAAMC,IAAAA,4BAAe,EAAC;YAChDT;YACAU,aAAaH;YACbI,gBAAgBC,sBAAU;QAC5B;QACA,OAAO,eACFL;YACHM,KAAKL;;IAET;IAGF,MAAMM,qBAAqB,MAAMC,IAAAA,mCAAsB,EACrDZ,qBACAH;IAGF,MAAMgB,MAAMC,IAAAA,4BAAe,EAACjB,OAAOc;IACnC,IAAI,CAACE,KAAK;QACR,MAAM,IAAIE,MAAM;IAClB;IAEA,MAAMC,YAAYC,IAAAA,iCAAoB,EAACJ;IAEvC,MAAMK,cAAe,MAAMT,IAAAA,sBAAU,EAACO;IACtC,MAAMG,eAAeC,IAAAA,6BAAgB,EAACF;IAEtC,MAAMG,kBAAkB,MAAMC,IAAAA,+BAAkB,EAAC;QAC/CzB;QACAU,aAAaI;QACbH,gBAAgBC,sBAAU;IAC5B;IAEA,MAAMc,mBAAmBC,IAAAA,uCAA0B,EACjDb,mBAAmBD,GAAG,EACtBW;IAGF;;GAEC,GACD,MAAMI,YAAYC,IAAAA,8CAAiC,EACjDH,kBACAxB,iBAAiB,CAAC;IAGpB;;GAEC,GACD,MAAM4B,uBAAuBR,aAAaS,OAAO,CAC/CC,4BAAe,EACf,CAAC,CAAC,EAAEJ,UAAU,KAAK,EAAEd,mBAAmBmB,IAAI,CAAC,CAAC;IAGhD;;GAEC,GACD,MAAMC,WAAWlC,MAAMkC,QAAQ;IAC/B,MAAMC,aAAanC,MAAMmC,UAAU,IAAI,EAAE;IACzC,MAAMC,aAAaC,IAAAA,sCAAyB,EAC1CF,YACAD,UACApB,oBACAgB;IAGF,OAAOM;AACT"}

package/src/duckdb-exec.d.ts

@@ -1 +1 @@
-export declare const duckdbExec: <T = unknown>(query: string) => Promise<T>;
+export declare const duckdbExec: (query: string) => Promise<Record<string, unknown>[]>;

package/src/duckdb-exec.js

@@ -6,16 +6,13 @@ Object.defineProperty(exports, "duckdbExec", {
     }
 });
 const _duckdbsingleton = require("./duckdb-singleton");
-const duckdbExec = (query)=>{
-    const db = _duckdbsingleton.DuckDBSingleton.getInstance();
-    return new Promise((resolve, reject)=>{
-        db.all(query, (err, res)=>{
-            if (err) {
-                reject(err);
-            }
-            resolve(res);
-        });
-    });
+const _transformduckdbresult = require("./utils/transform-duckdb-result");
+const duckdbExec = async (query)=>{
+    const db = await _duckdbsingleton.DuckDBSingleton.getInstance();
+    const connection = await db.connect();
+    const result = await connection.run(query);
+    const { data } = await (0, _transformduckdbresult.transformDuckDBQueryResult)(result);
+    return data;
 };
 
 //# sourceMappingURL=duckdb-exec.js.map

package/src/duckdb-exec.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-node/src/duckdb-exec.ts"],"sourcesContent":["import { DuckDBSingleton } from './duckdb-singleton';\n\nexport const duckdbExec = <T = unknown>(query: string): Promise<T> => {\n  const db = DuckDBSingleton.getInstance();\n  return new Promise((resolve, reject) => {\n    db.all(query, (err, res) => {\n      if (err) {\n        reject(err);\n      }\n      resolve(res as T);\n    });\n  });\n};\n"],"names":["duckdbExec","query","db","DuckDBSingleton","getInstance","Promise","resolve","reject","all","err","res"],"mappings":";+BAEaA;;;eAAAA;;;iCAFmB;AAEzB,MAAMA,aAAa,CAAcC;IACtC,MAAMC,KAAKC,gCAAe,CAACC,WAAW;IACtC,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3BL,GAAGM,GAAG,CAACP,OAAO,CAACQ,KAAKC;YAClB,IAAID,KAAK;gBACPF,OAAOE;YACT;YACAH,QAAQI;QACV;IACF;AACF"}
+{"version":3,"sources":["../../../meerkat-node/src/duckdb-exec.ts"],"sourcesContent":["import { DuckDBSingleton } from './duckdb-singleton';\nimport { transformDuckDBQueryResult } from './utils/transform-duckdb-result';\n\nexport const duckdbExec = async (\n  query: string\n): Promise<Record<string, unknown>[]> => {\n  const db = await DuckDBSingleton.getInstance();\n  const connection = await db.connect();\n\n  const result = await connection.run(query);\n\n  const { data } = await transformDuckDBQueryResult(result);\n\n  return data;\n};\n"],"names":["duckdbExec","query","db","DuckDBSingleton","getInstance","connection","connect","result","run","data","transformDuckDBQueryResult"],"mappings":";+BAGaA;;;eAAAA;;;iCAHmB;uCACW;AAEpC,MAAMA,aAAa,OACxBC;IAEA,MAAMC,KAAK,MAAMC,gCAAe,CAACC,WAAW;IAC5C,MAAMC,aAAa,MAAMH,GAAGI,OAAO;IAEnC,MAAMC,SAAS,MAAMF,WAAWG,GAAG,CAACP;IAEpC,MAAM,EAAEQ,IAAI,EAAE,GAAG,MAAMC,IAAAA,iDAA0B,EAACH;IAElD,OAAOE;AACT"}

package/src/duckdb-manager/duckdb-manager.d.ts

@@ -0,0 +1,19 @@
+import { DuckDBInstance } from '@duckdb/node-api';
+import { QueryResult } from '../utils/transform-duckdb-result';
+export declare class DuckDBManager {
+    private db;
+    private connection;
+    private initPromise;
+    constructor({ initializeDatabase, }: {
+        initializeDatabase?: (db: DuckDBInstance) => Promise<void>;
+    });
+    /**
+     * Initialize the DuckDB instance
+     */
+    private initialize;
+    private getConnection;
+    /**
+     * Execute a query on the DuckDB connection.
+     */
+    query(query: string): Promise<QueryResult>;
+}

package/src/duckdb-manager/duckdb-manager.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "DuckDBManager", {
+    enumerable: true,
+    get: function() {
+        return DuckDBManager;
+    }
+});
+const _duckdbsingleton = require("../duckdb-singleton");
+const _transformduckdbresult = require("../utils/transform-duckdb-result");
+let DuckDBManager = class DuckDBManager {
+    /**
+   * Initialize the DuckDB instance
+   */ async initialize({ initializeDatabase }) {
+        this.db = await _duckdbsingleton.DuckDBSingleton.getInstance();
+        await (initializeDatabase == null ? void 0 : initializeDatabase(this.db));
+    }
+    async getConnection() {
+        await this.initPromise;
+        if (!this.connection) {
+            var _this_db;
+            var _ref;
+            this.connection = (_ref = await ((_this_db = this.db) == null ? void 0 : _this_db.connect())) != null ? _ref : null;
+        }
+        return this.connection;
+    }
+    /**
+   * Execute a query on the DuckDB connection.
+   */ async query(query) {
+        const connection = await this.getConnection();
+        if (!connection) throw new Error('DuckDB connection not initialized');
+        const result = await connection.run(query);
+        const data = await (0, _transformduckdbresult.transformDuckDBQueryResult)(result);
+        return data;
+    }
+    constructor({ initializeDatabase }){
+        this.db = null;
+        this.connection = null;
+        this.initPromise = this.initialize({
+            initializeDatabase
+        });
+    }
+};
+
+//# sourceMappingURL=duckdb-manager.js.map

package/src/duckdb-manager/duckdb-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/duckdb-manager/duckdb-manager.ts"],"sourcesContent":["import { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport { DuckDBSingleton } from '../duckdb-singleton';\nimport {\n  QueryResult,\n  transformDuckDBQueryResult,\n} from '../utils/transform-duckdb-result';\n\nexport class DuckDBManager {\n  private db: DuckDBInstance | null = null;\n  private connection: DuckDBConnection | null = null;\n\n  private initPromise: Promise<void>;\n\n  constructor({\n    initializeDatabase,\n  }: {\n    initializeDatabase?: (db: DuckDBInstance) => Promise<void>;\n  }) {\n    this.initPromise = this.initialize({ initializeDatabase });\n  }\n\n  /**\n   * Initialize the DuckDB instance\n   */\n  private async initialize({\n    initializeDatabase,\n  }: {\n    initializeDatabase?: (db: DuckDBInstance) => Promise<void>;\n  }): Promise<void> {\n    this.db = await DuckDBSingleton.getInstance();\n\n    await initializeDatabase?.(this.db);\n  }\n\n  private async getConnection(): Promise<DuckDBConnection | null> {\n    await this.initPromise;\n\n    if (!this.connection) {\n      this.connection = (await this.db?.connect()) ?? null;\n    }\n\n    return this.connection;\n  }\n\n  /**\n   * Execute a query on the DuckDB connection.\n   */\n  async query(query: string): Promise<QueryResult> {\n    const connection = await this.getConnection();\n\n    if (!connection) throw new Error('DuckDB connection not initialized');\n\n    const result = await connection.run(query);\n\n    const data = await transformDuckDBQueryResult(result);\n\n    return data;\n  }\n}\n"],"names":["DuckDBManager","initialize","initializeDatabase","db","DuckDBSingleton","getInstance","getConnection","initPromise","connection","connect","query","Error","result","run","data","transformDuckDBQueryResult","constructor"],"mappings":";+BAOaA;;;eAAAA;;;iCANmB;uCAIzB;AAEA,IAAA,AAAMA,gBAAN,MAAMA;IAcX;;GAEC,GACD,MAAcC,WAAW,EACvBC,kBAAkB,EAGnB,EAAiB;QAChB,IAAI,CAACC,EAAE,GAAG,MAAMC,gCAAe,CAACC,WAAW;QAE3C,OAAMH,sCAAAA,mBAAqB,IAAI,CAACC,EAAE;IACpC;IAEA,MAAcG,gBAAkD;QAC9D,MAAM,IAAI,CAACC,WAAW;QAEtB,IAAI,CAAC,IAAI,CAACC,UAAU,EAAE;gBACK;gBAAN;YAAnB,IAAI,CAACA,UAAU,GAAG,CAAC,OAAA,QAAM,WAAA,IAAI,CAACL,EAAE,qBAAP,SAASM,OAAO,eAAtB,OAA6B;QAClD;QAEA,OAAO,IAAI,CAACD,UAAU;IACxB;IAEA;;GAEC,GACD,MAAME,MAAMA,KAAa,EAAwB;QAC/C,MAAMF,aAAa,MAAM,IAAI,CAACF,aAAa;QAE3C,IAAI,CAACE,YAAY,MAAM,IAAIG,MAAM;QAEjC,MAAMC,SAAS,MAAMJ,WAAWK,GAAG,CAACH;QAEpC,MAAMI,OAAO,MAAMC,IAAAA,iDAA0B,EAACH;QAE9C,OAAOE;IACT;IA5CAE,YAAY,EACVd,kBAAkB,EAGnB,CAAE;aATKC,KAA4B;aAC5BK,aAAsC;QAS5C,IAAI,CAACD,WAAW,GAAG,IAAI,CAACN,UAAU,CAAC;YAAEC;QAAmB;IAC1D;AAuCF"}

package/src/duckdb-singleton.d.ts

@@ -1,4 +1,4 @@
-import { Database } from 'duckdb';
+import { DuckDBInstance } from '@duckdb/node-api';
 /**
  * DuckDBSingleton is designed as a Singleton class, which ensures that only one Database connection exists across the entire application.
  * This reduces the overhead involved in establishing new connections for each database request.
@@ -14,5 +14,5 @@ import { Database } from 'duckdb';
 export declare class DuckDBSingleton {
     private static instance;
     private constructor();
-    static getInstance(): Database;
+    static getInstance(): Promise<DuckDBInstance>;
 }

package/src/duckdb-singleton.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "DuckDBSingleton", {
         return DuckDBSingleton;
     }
 });
-const _duckdb = require("duckdb");
+const _nodeapi = require("@duckdb/node-api");
 let DuckDBSingleton = class DuckDBSingleton {
-    static getInstance() {
+    static async getInstance() {
         if (!DuckDBSingleton.instance) {
-            DuckDBSingleton.instance = new _duckdb.Database(':memory:');
+            DuckDBSingleton.instance = await _nodeapi.DuckDBInstance.create(':memory:');
         }
         return DuckDBSingleton.instance;
     }

package/src/duckdb-singleton.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-node/src/duckdb-singleton.ts"],"sourcesContent":["import { Database } from 'duckdb';\n\n/**\n * DuckDBSingleton is designed as a Singleton class, which ensures that only one Database connection exists across the entire application.\n * This reduces the overhead involved in establishing new connections for each database request.\n *\n * The `getInstance` method returns a DuckDB Database instance. If an instance doesn't already exist, it creates one.\n * Subsequent calls to `getInstance` will return the pre-existing instance, ensuring there is only a single connection to the DuckDB instance throughout the use of the application.\n *\n * Usage: let duckDbConnection = DuckDBSingleton.getInstance();\n *\n * Note: In case of in-memory database, `new Database(':memory:')` in getInstance method. In-memory databases are faster for read/write operations\n * but are not persistent; they lose data as soon as the program ends or the machine is turned off, which is okay for our use-case.\n */\nexport class DuckDBSingleton {\n  private static instance: Database;\n\n  private constructor() {\n    // private to prevent direct instantiation.\n  }\n\n  static getInstance(): Database {\n    if (!DuckDBSingleton.instance) {\n      DuckDBSingleton.instance = new Database(':memory:');\n    }\n    return DuckDBSingleton.instance;\n  }\n}\n"],"names":["DuckDBSingleton","getInstance","instance","Database"],"mappings":";+BAcaA;;;eAAAA;;;wBAdY;AAclB,IAAA,AAAMA,kBAAN,MAAMA;IAOX,OAAOC,cAAwB;QAC7B,IAAI,CAACD,gBAAgBE,QAAQ,EAAE;YAC7BF,gBAAgBE,QAAQ,GAAG,IAAIC,gBAAQ,CAAC;QAC1C;QACA,OAAOH,gBAAgBE,QAAQ;IACjC;IATA,aAAsB;IACpB,2CAA2C;IAC7C;AAQF"}
+{"version":3,"sources":["../../../meerkat-node/src/duckdb-singleton.ts"],"sourcesContent":["import { DuckDBInstance } from '@duckdb/node-api';\n\n/**\n * DuckDBSingleton is designed as a Singleton class, which ensures that only one Database connection exists across the entire application.\n * This reduces the overhead involved in establishing new connections for each database request.\n *\n * The `getInstance` method returns a DuckDB Database instance. If an instance doesn't already exist, it creates one.\n * Subsequent calls to `getInstance` will return the pre-existing instance, ensuring there is only a single connection to the DuckDB instance throughout the use of the application.\n *\n * Usage: let duckDbConnection = DuckDBSingleton.getInstance();\n *\n * Note: In case of in-memory database, `new Database(':memory:')` in getInstance method. In-memory databases are faster for read/write operations\n * but are not persistent; they lose data as soon as the program ends or the machine is turned off, which is okay for our use-case.\n */\nexport class DuckDBSingleton {\n  private static instance: DuckDBInstance;\n\n  private constructor() {\n    // private to prevent direct instantiation.\n  }\n\n  static async getInstance(): Promise<DuckDBInstance> {\n    if (!DuckDBSingleton.instance) {\n      DuckDBSingleton.instance = await DuckDBInstance.create(':memory:');\n    }\n    return DuckDBSingleton.instance;\n  }\n}\n"],"names":["DuckDBSingleton","getInstance","instance","DuckDBInstance","create"],"mappings":";+BAcaA;;;eAAAA;;;yBAdkB;AAcxB,IAAA,AAAMA,kBAAN,MAAMA;IAOX,aAAaC,cAAuC;QAClD,IAAI,CAACD,gBAAgBE,QAAQ,EAAE;YAC7BF,gBAAgBE,QAAQ,GAAG,MAAMC,uBAAc,CAACC,MAAM,CAAC;QACzD;QACA,OAAOJ,gBAAgBE,QAAQ;IACjC;IATA,aAAsB;IACpB,2CAA2C;IAC7C;AAQF"}

package/src/file-manager/file-manager.d.ts

@@ -0,0 +1,32 @@
+export declare class FileManager {
+    private readonly baseDir;
+    constructor(config: {
+        baseDir?: string;
+    });
+    getPath(tableName: string, fileName?: string): string;
+    /**
+     * Write a file buffer to the file system.
+     */
+    writeFileBuffer(file: {
+        tableName: string;
+        fileName: string;
+        buffer: Uint8Array;
+    }): Promise<void>;
+    /**
+     * Get the file paths for a table.
+     */
+    getTableFilePaths(tableName: string): Promise<string[]>;
+    /**
+     * Delete files from a table.
+     */
+    deleteTableFiles(tableName: string, files: string[]): Promise<void>;
+    /**
+     * Stream and register a file from a URL.
+     */
+    streamAndRegisterFile({ tableName, url, headers, fileName, }: {
+        tableName: string;
+        url: string;
+        headers: Record<string, string>;
+        fileName: string;
+    }): Promise<void>;
+}

package/src/file-manager/file-manager.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "FileManager", {
+    enumerable: true,
+    get: function() {
+        return FileManager;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _axios = require("axios");
+const _fs = require("fs");
+const _path = require("path");
+const _encryptstring = require("../utils/encrypt-string");
+let FileManager = class FileManager {
+    getPath(tableName, fileName) {
+        return fileName ? _path.join(this.baseDir, tableName, fileName) : _path.join(this.baseDir, tableName);
+    }
+    /**
+   * Write a file buffer to the file system.
+   */ async writeFileBuffer(file) {
+        // Hash the file name to avoid file name length issues
+        const hashedFileName = (0, _encryptstring.encryptString)(file.fileName);
+        const filePath = this.getPath(file.tableName, hashedFileName);
+        await _fs.promises.mkdir(_path.dirname(filePath), {
+            recursive: true
+        });
+        await _fs.promises.writeFile(filePath, file.buffer);
+    }
+    /**
+   * Get the file paths for a table.
+   */ async getTableFilePaths(tableName) {
+        try {
+            const files = await _fs.promises.readdir(this.getPath(tableName));
+            return files.map((file)=>this.getPath(tableName, file));
+        } catch (e) {
+            return [];
+        }
+    }
+    /**
+   * Delete files from a table.
+   */ async deleteTableFiles(tableName, files) {
+        await Promise.all(files.map(async (file)=>{
+            try {
+                await _fs.promises.unlink(this.getPath(tableName, file));
+            } catch (err) {
+                console.error(err);
+            }
+        }));
+    }
+    /**
+   * Stream and register a file from a URL.
+   */ async streamAndRegisterFile({ tableName, url, headers, fileName }) {
+        try {
+            const response = await (0, _axios.default)({
+                headers: _extends._({}, headers),
+                method: 'get',
+                responseType: 'stream',
+                url
+            });
+            const hashedFileName = (0, _encryptstring.encryptString)(fileName);
+            const filePath = this.getPath(tableName, hashedFileName);
+            await _fs.promises.mkdir(_path.dirname(filePath), {
+                recursive: true
+            });
+            const writer = (0, _fs.createWriteStream)(filePath);
+            return new Promise((resolve, reject)=>{
+                response.data.pipe(writer);
+                writer.on('finish', ()=>{
+                    writer.close();
+                    resolve();
+                });
+                writer.on('error', (err)=>{
+                    writer.close();
+                    reject(err);
+                });
+            });
+        } catch (error) {
+            console.error('Error streaming file:', error);
+            throw error;
+        }
+    }
+    constructor(config){
+        var _config_baseDir;
+        this.baseDir = (_config_baseDir = config.baseDir) != null ? _config_baseDir : './data';
+        _fs.promises.mkdir(this.baseDir, {
+            recursive: true
+        }).catch(console.error);
+    }
+};
+
+//# sourceMappingURL=file-manager.js.map

package/src/file-manager/file-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/file-manager/file-manager.ts"],"sourcesContent":["import axios from 'axios';\nimport { createWriteStream, promises as fs } from 'fs';\nimport * as path from 'path';\n\nimport { encryptString } from '../utils/encrypt-string';\n\nexport class FileManager {\n  private readonly baseDir: string;\n\n  constructor(config: { baseDir?: string }) {\n    this.baseDir = config.baseDir ?? './data';\n    fs.mkdir(this.baseDir, { recursive: true }).catch(console.error);\n  }\n\n  public getPath(tableName: string, fileName?: string): string {\n    return fileName\n      ? path.join(this.baseDir, tableName, fileName)\n      : path.join(this.baseDir, tableName);\n  }\n\n  /**\n   * Write a file buffer to the file system.\n   */\n  async writeFileBuffer(file: {\n    tableName: string;\n    fileName: string;\n    buffer: Uint8Array;\n  }): Promise<void> {\n    // Hash the file name to avoid file name length issues\n    const hashedFileName = encryptString(file.fileName);\n\n    const filePath = this.getPath(file.tableName, hashedFileName);\n\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n\n    await fs.writeFile(filePath, file.buffer);\n  }\n\n  /**\n   * Get the file paths for a table.\n   */\n  async getTableFilePaths(tableName: string): Promise<string[]> {\n    try {\n      const files = await fs.readdir(this.getPath(tableName));\n\n      return files.map((file) => this.getPath(tableName, file));\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Delete files from a table.\n   */\n  async deleteTableFiles(tableName: string, files: string[]): Promise<void> {\n    await Promise.all(\n      files.map(async (file) => {\n        try {\n          await fs.unlink(this.getPath(tableName, file));\n        } catch (err) {\n          console.error(err);\n        }\n      })\n    );\n  }\n\n  /**\n   * Stream and register a file from a URL.\n   */\n  async streamAndRegisterFile({\n    tableName,\n    url,\n    headers,\n    fileName,\n  }: {\n    tableName: string;\n    url: string;\n    headers: Record<string, string>;\n    fileName: string;\n  }): Promise<void> {\n    try {\n      const response = await axios({\n        headers: {\n          ...headers,\n        },\n        method: 'get',\n        responseType: 'stream',\n        url,\n      });\n\n      const hashedFileName = encryptString(fileName);\n\n      const filePath = this.getPath(tableName, hashedFileName);\n      await fs.mkdir(path.dirname(filePath), { recursive: true });\n\n      const writer = createWriteStream(filePath);\n\n      return new Promise((resolve, reject) => {\n        response.data.pipe(writer);\n        writer.on('finish', () => {\n          writer.close();\n          resolve();\n        });\n        writer.on('error', (err) => {\n          writer.close();\n          reject(err);\n        });\n      });\n    } catch (error) {\n      console.error('Error streaming file:', error);\n      throw error;\n    }\n  }\n}\n"],"names":["FileManager","getPath","tableName","fileName","path","join","baseDir","writeFileBuffer","file","hashedFileName","encryptString","filePath","fs","mkdir","dirname","recursive","writeFile","buffer","getTableFilePaths","files","readdir","map","deleteTableFiles","Promise","all","unlink","err","console","error","streamAndRegisterFile","url","headers","response","axios","method","responseType","writer","createWriteStream","resolve","reject","data","pipe","on","close","constructor","config","catch"],"mappings":";+BAMaA;;;eAAAA;;;;uBANK;oBACgC;sBAC5B;+BAEQ;AAEvB,IAAA,AAAMA,cAAN,MAAMA;IAQJC,QAAQC,SAAiB,EAAEC,QAAiB,EAAU;QAC3D,OAAOA,WACHC,MAAKC,IAAI,CAAC,IAAI,CAACC,OAAO,EAAEJ,WAAWC,YACnCC,MAAKC,IAAI,CAAC,IAAI,CAACC,OAAO,EAAEJ;IAC9B;IAEA;;GAEC,GACD,MAAMK,gBAAgBC,IAIrB,EAAiB;QAChB,sDAAsD;QACtD,MAAMC,iBAAiBC,IAAAA,4BAAa,EAACF,KAAKL,QAAQ;QAElD,MAAMQ,WAAW,IAAI,CAACV,OAAO,CAACO,KAAKN,SAAS,EAAEO;QAE9C,MAAMG,YAAE,CAACC,KAAK,CAACT,MAAKU,OAAO,CAACH,WAAW;YAAEI,WAAW;QAAK;QAEzD,MAAMH,YAAE,CAACI,SAAS,CAACL,UAAUH,KAAKS,MAAM;IAC1C;IAEA;;GAEC,GACD,MAAMC,kBAAkBhB,SAAiB,EAAqB;QAC5D,IAAI;YACF,MAAMiB,QAAQ,MAAMP,YAAE,CAACQ,OAAO,CAAC,IAAI,CAACnB,OAAO,CAACC;YAE5C,OAAOiB,MAAME,GAAG,CAAC,CAACb,OAAS,IAAI,CAACP,OAAO,CAACC,WAAWM;QACrD,EAAE,UAAM;YACN,OAAO,EAAE;QACX;IACF;IAEA;;GAEC,GACD,MAAMc,iBAAiBpB,SAAiB,EAAEiB,KAAe,EAAiB;QACxE,MAAMI,QAAQC,GAAG,CACfL,MAAME,GAAG,CAAC,OAAOb;YACf,IAAI;gBACF,MAAMI,YAAE,CAACa,MAAM,CAAC,IAAI,CAACxB,OAAO,CAACC,WAAWM;YAC1C,EAAE,OAAOkB,KAAK;gBACZC,QAAQC,KAAK,CAACF;YAChB;QACF;IAEJ;IAEA;;GAEC,GACD,MAAMG,sBAAsB,EAC1B3B,SAAS,EACT4B,GAAG,EACHC,OAAO,EACP5B,QAAQ,EAMT,EAAiB;QAChB,IAAI;YACF,MAAM6B,WAAW,MAAMC,IAAAA,cAAK,EAAC;gBAC3BF,SAAS,eACJA;gBAELG,QAAQ;gBACRC,cAAc;gBACdL;YACF;YAEA,MAAMrB,iBAAiBC,IAAAA,4BAAa,EAACP;YAErC,MAAMQ,WAAW,IAAI,CAACV,OAAO,CAACC,WAAWO;YACzC,MAAMG,YAAE,CAACC,KAAK,CAACT,MAAKU,OAAO,CAACH,WAAW;gBAAEI,WAAW;YAAK;YAEzD,MAAMqB,SAASC,IAAAA,qBAAiB,EAAC1B;YAEjC,OAAO,IAAIY,QAAQ,CAACe,SAASC;gBAC3BP,SAASQ,IAAI,CAACC,IAAI,CAACL;gBACnBA,OAAOM,EAAE,CAAC,UAAU;oBAClBN,OAAOO,KAAK;oBACZL;gBACF;gBACAF,OAAOM,EAAE,CAAC,SAAS,CAAChB;oBAClBU,OAAOO,KAAK;oBACZJ,OAAOb;gBACT;YACF;QACF,EAAE,OAAOE,OAAO;YACdD,QAAQC,KAAK,CAAC,yBAAyBA;YACvC,MAAMA;QACR;IACF;IAvGAgB,YAAYC,MAA4B,CAAE;YACzBA;QAAf,IAAI,CAACvC,OAAO,GAAGuC,CAAAA,kBAAAA,OAAOvC,OAAO,YAAduC,kBAAkB;QACjCjC,YAAE,CAACC,KAAK,CAAC,IAAI,CAACP,OAAO,EAAE;YAAES,WAAW;QAAK,GAAG+B,KAAK,CAACnB,QAAQC,KAAK;IACjE;AAqGF"}

package/src/index.d.ts

@@ -3,3 +3,5 @@ export * from './duckdb-singleton';
 export * from './node-sql-to-serialization';
 export { convertCubeStringToTableSchema };
 import { convertCubeStringToTableSchema } from '@devrev/meerkat-core';
+export * from './duckdb-manager/duckdb-manager';
+export * from './file-manager/file-manager';

package/src/index.js

@@ -10,5 +10,7 @@ _export_star._(require("./cube-to-sql/cube-to-sql"), exports);
 _export_star._(require("./duckdb-singleton"), exports);
 _export_star._(require("./node-sql-to-serialization"), exports);
 const _meerkatcore = require("@devrev/meerkat-core");
+_export_star._(require("./duckdb-manager/duckdb-manager"), exports);
+_export_star._(require("./file-manager/file-manager"), exports);
 
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-node/src/index.ts"],"sourcesContent":["export * from './cube-to-sql/cube-to-sql';\nexport * from './duckdb-singleton';\nexport * from './node-sql-to-serialization';\nexport { convertCubeStringToTableSchema };\nimport { convertCubeStringToTableSchema } from '@devrev/meerkat-core';\n"],"names":["convertCubeStringToTableSchema"],"mappings":";+BAGSA;;;eAAAA,2CAA8B;;;;uBAHzB;uBACA;uBACA;6BAEiC"}
+{"version":3,"sources":["../../../meerkat-node/src/index.ts"],"sourcesContent":["export * from './cube-to-sql/cube-to-sql';\nexport * from './duckdb-singleton';\nexport * from './node-sql-to-serialization';\nexport { convertCubeStringToTableSchema };\nimport { convertCubeStringToTableSchema } from '@devrev/meerkat-core';\nexport * from './duckdb-manager/duckdb-manager';\nexport * from './file-manager/file-manager';\n"],"names":["convertCubeStringToTableSchema"],"mappings":";+BAGSA;;;eAAAA,2CAA8B;;;;uBAHzB;uBACA;uBACA;6BAEiC;uBACjC;uBACA"}

package/src/node-sql-to-serialization.js

@@ -12,7 +12,6 @@ const nodeSQLToSerialization = async (sql)=>{
     for(const key in queryOutput[0]){
         if (Object.prototype.hasOwnProperty.call(queryOutput[0], key)) {
             parsedOutput[key] = JSON.parse(queryOutput[0][key]);
-            break;
         }
     }
     return parsedOutput;

package/src/node-sql-to-serialization.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-node/src/node-sql-to-serialization.ts"],"sourcesContent":["import { SelectStatement } from '@devrev/meerkat-core';\nimport { duckdbExec } from './duckdb-exec';\n\nexport interface ParsedSerialization {\n  [key: string]: {\n    error: boolean;\n    statements: SelectStatement[];\n  };\n}\n\nexport const nodeSQLToSerialization = async (\n  sql: string\n): Promise<ParsedSerialization> => {\n  const queryOutput = await duckdbExec<\n    {\n      [key: string]: string;\n    }[]\n  >(sql);\n\n  const parsedOutput: ParsedSerialization = {};\n\n  for (const key in queryOutput[0]) {\n    if (Object.prototype.hasOwnProperty.call(queryOutput[0], key)) {\n      parsedOutput[key] = JSON.parse(queryOutput[0][key]) as {\n        error: boolean;\n        statements: SelectStatement[];\n      };\n      break;\n    }\n  }\n  return parsedOutput;\n};\n"],"names":["nodeSQLToSerialization","sql","queryOutput","duckdbExec","parsedOutput","key","Object","prototype","hasOwnProperty","call","JSON","parse"],"mappings":";+BAUaA;;;eAAAA;;;4BATc;AASpB,MAAMA,yBAAyB,OACpCC;IAEA,MAAMC,cAAc,MAAMC,IAAAA,sBAAU,EAIlCF;IAEF,MAAMG,eAAoC,CAAC;IAE3C,IAAK,MAAMC,OAAOH,WAAW,CAAC,EAAE,CAAE;QAChC,IAAII,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,WAAW,CAAC,EAAE,EAAEG,MAAM;YAC7DD,YAAY,CAACC,IAAI,GAAGK,KAAKC,KAAK,CAACT,WAAW,CAAC,EAAE,CAACG,IAAI;YAIlD;QACF;IACF;IACA,OAAOD;AACT"}
+{"version":3,"sources":["../../../meerkat-node/src/node-sql-to-serialization.ts"],"sourcesContent":["import { SelectStatement } from '@devrev/meerkat-core';\nimport { duckdbExec } from './duckdb-exec';\n\nexport interface ParsedSerialization {\n  [key: string]: {\n    error: boolean;\n    statements: SelectStatement[];\n  };\n}\n\nexport const nodeSQLToSerialization = async (\n  sql: string\n): Promise<ParsedSerialization> => {\n  const queryOutput = await duckdbExec(sql);\n\n  const parsedOutput: ParsedSerialization = {};\n\n  for (const key in queryOutput[0]) {\n    if (Object.prototype.hasOwnProperty.call(queryOutput[0], key)) {\n      parsedOutput[key] = JSON.parse(queryOutput[0][key] as string) as {\n        error: boolean;\n        statements: SelectStatement[];\n      };\n    }\n  }\n  return parsedOutput;\n};\n"],"names":["nodeSQLToSerialization","sql","queryOutput","duckdbExec","parsedOutput","key","Object","prototype","hasOwnProperty","call","JSON","parse"],"mappings":";+BAUaA;;;eAAAA;;;4BATc;AASpB,MAAMA,yBAAyB,OACpCC;IAEA,MAAMC,cAAc,MAAMC,IAAAA,sBAAU,EAACF;IAErC,MAAMG,eAAoC,CAAC;IAE3C,IAAK,MAAMC,OAAOH,WAAW,CAAC,EAAE,CAAE;QAChC,IAAII,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,WAAW,CAAC,EAAE,EAAEG,MAAM;YAC7DD,YAAY,CAACC,IAAI,GAAGK,KAAKC,KAAK,CAACT,WAAW,CAAC,EAAE,CAACG,IAAI;QAIpD;IACF;IACA,OAAOD;AACT"}

package/src/utils/convert-rows-to-records.d.ts

@@ -0,0 +1,2 @@
+import { DuckDBValue } from '@duckdb/node-api';
+export declare const convertRowsToRecords: (rows: DuckDBValue[][], columnNames: string[]) => Record<string, DuckDBValue>[];

package/src/utils/convert-rows-to-records.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "convertRowsToRecords", {
+    enumerable: true,
+    get: function() {
+        return convertRowsToRecords;
+    }
+});
+const convertRowsToRecords = (rows, columnNames)=>{
+    return rows.map((row)=>{
+        return columnNames.reduce((obj, columnName, index)=>{
+            obj[columnName] = row[index];
+            return obj;
+        }, {});
+    });
+};
+
+//# sourceMappingURL=convert-rows-to-records.js.map

package/src/utils/convert-rows-to-records.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/utils/convert-rows-to-records.ts"],"sourcesContent":["import { DuckDBValue } from '@duckdb/node-api';\n\nexport const convertRowsToRecords = (\n  rows: DuckDBValue[][],\n  columnNames: string[]\n) => {\n  return rows.map((row) => {\n    return columnNames.reduce((obj, columnName, index) => {\n      obj[columnName] = row[index];\n      return obj;\n    }, {} as Record<string, DuckDBValue>);\n  });\n};\n"],"names":["convertRowsToRecords","rows","columnNames","map","row","reduce","obj","columnName","index"],"mappings":";+BAEaA;;;eAAAA;;;AAAN,MAAMA,uBAAuB,CAClCC,MACAC;IAEA,OAAOD,KAAKE,GAAG,CAAC,CAACC;QACf,OAAOF,YAAYG,MAAM,CAAC,CAACC,KAAKC,YAAYC;YAC1CF,GAAG,CAACC,WAAW,GAAGH,GAAG,CAACI,MAAM;YAC5B,OAAOF;QACT,GAAG,CAAC;IACN;AACF"}

package/src/utils/duckdb-type-convertor.d.ts

@@ -0,0 +1,6 @@
+import { DuckDBType, DuckDBValue } from '@duckdb/node-api';
+export declare const convertDuckDBValueToJS: (field: DuckDBType, value: DuckDBValue) => unknown;
+export declare const convertRecordDuckDBValueToJSON: (data: Record<string, DuckDBValue>[], columns: {
+    name: string;
+    type: DuckDBType;
+}[]) => Record<string, unknown>[];

package/src/utils/duckdb-type-convertor.js

@@ -0,0 +1,61 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    convertDuckDBValueToJS: function() {
+        return convertDuckDBValueToJS;
+    },
+    convertRecordDuckDBValueToJSON: function() {
+        return convertRecordDuckDBValueToJSON;
+    }
+});
+const _nodeapi = require("@duckdb/node-api");
+const _lodash = require("lodash");
+const convertDuckDBValueToJS = (field, value)=>{
+    if ((0, _lodash.isNil)(value)) return value;
+    switch(field.typeId){
+        case _nodeapi.DuckDBTypeId.SQLNULL:
+            return null;
+        case _nodeapi.DuckDBTypeId.DATE:
+        case _nodeapi.DuckDBTypeId.TIMESTAMP:
+        case _nodeapi.DuckDBTypeId.TIME:
+            return new Date(value).toISOString();
+        case _nodeapi.DuckDBTypeId.FLOAT:
+        case _nodeapi.DuckDBTypeId.DOUBLE:
+            return value;
+        case _nodeapi.DuckDBTypeId.INTEGER:
+        case _nodeapi.DuckDBTypeId.TINYINT:
+        case _nodeapi.DuckDBTypeId.SMALLINT:
+        case _nodeapi.DuckDBTypeId.BIGINT:
+        case _nodeapi.DuckDBTypeId.UTINYINT:
+        case _nodeapi.DuckDBTypeId.USMALLINT:
+        case _nodeapi.DuckDBTypeId.UINTEGER:
+        case _nodeapi.DuckDBTypeId.UBIGINT:
+            return parseInt(value.toString());
+        case _nodeapi.DuckDBTypeId.DECIMAL:
+            return parseFloat(value.toString());
+        case _nodeapi.DuckDBTypeId.LIST:
+            {
+                if (!value) return [];
+                const listValue = value;
+                return listValue.items.map((item)=>convertDuckDBValueToJS(field.valueType, item));
+            }
+        default:
+            return value;
+    }
+};
+const convertRecordDuckDBValueToJSON = (data, columns)=>{
+    console.log(data);
+    return data.map((row)=>{
+        return columns.reduce((acc, column)=>{
+            acc[column.name] = convertDuckDBValueToJS(column.type, row[column.name]);
+            return acc;
+        }, {});
+    });
+};
+
+//# sourceMappingURL=duckdb-type-convertor.js.map

package/src/utils/duckdb-type-convertor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/utils/duckdb-type-convertor.ts"],"sourcesContent":["import {\n  DuckDBListValue,\n  DuckDBType,\n  DuckDBTypeId,\n  DuckDBValue,\n} from '@duckdb/node-api';\nimport { isNil } from 'lodash';\n\nexport const convertDuckDBValueToJS = (\n  field: DuckDBType,\n  value: DuckDBValue\n): unknown => {\n  if (isNil(value)) return value;\n\n  switch (field.typeId) {\n    case DuckDBTypeId.SQLNULL:\n      return null;\n    case DuckDBTypeId.DATE:\n    case DuckDBTypeId.TIMESTAMP:\n    case DuckDBTypeId.TIME:\n      return new Date(value as number).toISOString();\n    case DuckDBTypeId.FLOAT:\n    case DuckDBTypeId.DOUBLE:\n      return value;\n    case DuckDBTypeId.INTEGER:\n    case DuckDBTypeId.TINYINT:\n    case DuckDBTypeId.SMALLINT:\n    case DuckDBTypeId.BIGINT:\n    case DuckDBTypeId.UTINYINT:\n    case DuckDBTypeId.USMALLINT:\n    case DuckDBTypeId.UINTEGER:\n    case DuckDBTypeId.UBIGINT:\n      return parseInt((value as object).toString());\n    case DuckDBTypeId.DECIMAL:\n      return parseFloat((value as object).toString());\n    case DuckDBTypeId.LIST: {\n      if (!value) return [];\n      const listValue = value as DuckDBListValue;\n      return listValue.items.map((item) =>\n        convertDuckDBValueToJS(field.valueType, item)\n      );\n    }\n    default:\n      return value;\n  }\n};\n\nexport const convertRecordDuckDBValueToJSON = (\n  data: Record<string, DuckDBValue>[],\n  columns: { name: string; type: DuckDBType }[]\n): Record<string, unknown>[] => {\n  console.log(data);\n  return data.map((row: Record<string, DuckDBValue>) => {\n    return columns.reduce((acc, column) => {\n      acc[column.name] = convertDuckDBValueToJS(column.type, row[column.name]);\n      return acc;\n    }, {} as Record<string, unknown>);\n  });\n};\n"],"names":["convertDuckDBValueToJS","convertRecordDuckDBValueToJSON","field","value","isNil","typeId","DuckDBTypeId","SQLNULL","DATE","TIMESTAMP","TIME","Date","toISOString","FLOAT","DOUBLE","INTEGER","TINYINT","SMALLINT","BIGINT","UTINYINT","USMALLINT","UINTEGER","UBIGINT","parseInt","toString","DECIMAL","parseFloat","LIST","listValue","items","map","item","valueType","data","columns","console","log","row","reduce","acc","column","name","type"],"mappings":";;;;;;;;IAQaA,sBAAsB;eAAtBA;;IAuCAC,8BAA8B;eAA9BA;;;yBA1CN;wBACe;AAEf,MAAMD,yBAAyB,CACpCE,OACAC;IAEA,IAAIC,IAAAA,aAAK,EAACD,QAAQ,OAAOA;IAEzB,OAAQD,MAAMG,MAAM;QAClB,KAAKC,qBAAY,CAACC,OAAO;YACvB,OAAO;QACT,KAAKD,qBAAY,CAACE,IAAI;QACtB,KAAKF,qBAAY,CAACG,SAAS;QAC3B,KAAKH,qBAAY,CAACI,IAAI;YACpB,OAAO,IAAIC,KAAKR,OAAiBS,WAAW;QAC9C,KAAKN,qBAAY,CAACO,KAAK;QACvB,KAAKP,qBAAY,CAACQ,MAAM;YACtB,OAAOX;QACT,KAAKG,qBAAY,CAACS,OAAO;QACzB,KAAKT,qBAAY,CAACU,OAAO;QACzB,KAAKV,qBAAY,CAACW,QAAQ;QAC1B,KAAKX,qBAAY,CAACY,MAAM;QACxB,KAAKZ,qBAAY,CAACa,QAAQ;QAC1B,KAAKb,qBAAY,CAACc,SAAS;QAC3B,KAAKd,qBAAY,CAACe,QAAQ;QAC1B,KAAKf,qBAAY,CAACgB,OAAO;YACvB,OAAOC,SAAS,AAACpB,MAAiBqB,QAAQ;QAC5C,KAAKlB,qBAAY,CAACmB,OAAO;YACvB,OAAOC,WAAW,AAACvB,MAAiBqB,QAAQ;QAC9C,KAAKlB,qBAAY,CAACqB,IAAI;YAAE;gBACtB,IAAI,CAACxB,OAAO,OAAO,EAAE;gBACrB,MAAMyB,YAAYzB;gBAClB,OAAOyB,UAAUC,KAAK,CAACC,GAAG,CAAC,CAACC,OAC1B/B,uBAAuBE,MAAM8B,SAAS,EAAED;YAE5C;QACA;YACE,OAAO5B;IACX;AACF;AAEO,MAAMF,iCAAiC,CAC5CgC,MACAC;IAEAC,QAAQC,GAAG,CAACH;IACZ,OAAOA,KAAKH,GAAG,CAAC,CAACO;QACf,OAAOH,QAAQI,MAAM,CAAC,CAACC,KAAKC;YAC1BD,GAAG,CAACC,OAAOC,IAAI,CAAC,GAAGzC,uBAAuBwC,OAAOE,IAAI,EAAEL,GAAG,CAACG,OAAOC,IAAI,CAAC;YACvE,OAAOF;QACT,GAAG,CAAC;IACN;AACF"}

package/src/utils/encrypt-string.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encrypts a given string
+ */
+export declare const encryptString: (text: string) => string;
+/**
+ * Decrypts an encrypted string
+ */
+export declare const decryptString: (encryptedText: string) => string;

package/src/utils/encrypt-string.js

@@ -0,0 +1,39 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    encryptString: function() {
+        return encryptString;
+    },
+    decryptString: function() {
+        return decryptString;
+    }
+});
+const _crypto = require("crypto");
+const ENCRYPTION_KEY = _crypto.randomBytes(32);
+const ALGORITHM = 'aes-256-cbc';
+const encryptString = (text)=>{
+    const iv = _crypto.randomBytes(16);
+    const cipher = _crypto.createCipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
+    const encrypted = Buffer.concat([
+        cipher.update(text),
+        cipher.final()
+    ]);
+    return iv.toString('hex') + encrypted.toString('hex');
+};
+const decryptString = (encryptedText)=>{
+    // First 32 chars are IV (16 bytes in hex)
+    const iv = encryptedText.slice(0, 32);
+    const encrypted = Buffer.from(encryptedText.slice(32), 'hex');
+    const decipher = _crypto.createDecipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
+    return Buffer.concat([
+        decipher.update(encrypted),
+        decipher.final()
+    ]).toString();
+};
+
+//# sourceMappingURL=encrypt-string.js.map

package/src/utils/encrypt-string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/utils/encrypt-string.ts"],"sourcesContent":["import * as crypto from 'crypto';\n\nconst ENCRYPTION_KEY = crypto.randomBytes(32);\nconst ALGORITHM = 'aes-256-cbc';\n\n/**\n * Encrypts a given string\n */\nexport const encryptString = (text: string): string => {\n  const iv = crypto.randomBytes(16);\n\n  const cipher = crypto.createCipheriv(ALGORITHM, ENCRYPTION_KEY, iv);\n\n  const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);\n\n  return iv.toString('hex') + encrypted.toString('hex');\n};\n\n/**\n * Decrypts an encrypted string\n */\nexport const decryptString = (encryptedText: string): string => {\n  // First 32 chars are IV (16 bytes in hex)\n  const iv = encryptedText.slice(0, 32);\n\n  const encrypted = Buffer.from(encryptedText.slice(32), 'hex');\n\n  const decipher = crypto.createDecipheriv(ALGORITHM, ENCRYPTION_KEY, iv);\n\n  return Buffer.concat([\n    decipher.update(encrypted),\n    decipher.final(),\n  ]).toString();\n};\n"],"names":["encryptString","decryptString","ENCRYPTION_KEY","crypto","randomBytes","ALGORITHM","text","iv","cipher","createCipheriv","encrypted","Buffer","concat","update","final","toString","encryptedText","slice","from","decipher","createDecipheriv"],"mappings":";;;;;;;;IAQaA,aAAa;eAAbA;;IAaAC,aAAa;eAAbA;;;wBArBW;AAExB,MAAMC,iBAAiBC,QAAOC,WAAW,CAAC;AAC1C,MAAMC,YAAY;AAKX,MAAML,gBAAgB,CAACM;IAC5B,MAAMC,KAAKJ,QAAOC,WAAW,CAAC;IAE9B,MAAMI,SAASL,QAAOM,cAAc,CAACJ,WAAWH,gBAAgBK;IAEhE,MAAMG,YAAYC,OAAOC,MAAM,CAAC;QAACJ,OAAOK,MAAM,CAACP;QAAOE,OAAOM,KAAK;KAAG;IAErE,OAAOP,GAAGQ,QAAQ,CAAC,SAASL,UAAUK,QAAQ,CAAC;AACjD;AAKO,MAAMd,gBAAgB,CAACe;IAC5B,0CAA0C;IAC1C,MAAMT,KAAKS,cAAcC,KAAK,CAAC,GAAG;IAElC,MAAMP,YAAYC,OAAOO,IAAI,CAACF,cAAcC,KAAK,CAAC,KAAK;IAEvD,MAAME,WAAWhB,QAAOiB,gBAAgB,CAACf,WAAWH,gBAAgBK;IAEpE,OAAOI,OAAOC,MAAM,CAAC;QACnBO,SAASN,MAAM,CAACH;QAChBS,SAASL,KAAK;KACf,EAAEC,QAAQ;AACb"}

package/src/utils/transform-duckdb-result.d.ts

@@ -0,0 +1,13 @@
+import { DuckDBResult, DuckDBType } from '@duckdb/node-api';
+export interface ColumnMetadata {
+    name: string;
+    type: DuckDBType;
+}
+export interface QueryResult {
+    data: Record<string, unknown>[];
+    schema: ColumnMetadata[];
+}
+/**
+ * Converts raw DuckDB query results into a structured format with named objects
+ */
+export declare const transformDuckDBQueryResult: (result: DuckDBResult) => Promise<QueryResult>;

package/src/utils/transform-duckdb-result.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "transformDuckDBQueryResult", {
+    enumerable: true,
+    get: function() {
+        return transformDuckDBQueryResult;
+    }
+});
+const _convertrowstorecords = require("./convert-rows-to-records");
+const _duckdbtypeconvertor = require("./duckdb-type-convertor");
+const transformDuckDBQueryResult = async (result)=>{
+    const columnNames = result.columnNames();
+    const columnTypes = result.columnTypes();
+    const columns = columnNames.map((name, index)=>({
+            name,
+            type: columnTypes[index]
+        }));
+    const rows = await result.getRows();
+    const records = (0, _convertrowstorecords.convertRowsToRecords)(rows, result.columnNames());
+    const data = (0, _duckdbtypeconvertor.convertRecordDuckDBValueToJSON)(records, columns);
+    return {
+        data,
+        schema: columns
+    };
+};
+
+//# sourceMappingURL=transform-duckdb-result.js.map

package/src/utils/transform-duckdb-result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/utils/transform-duckdb-result.ts"],"sourcesContent":["import { DuckDBResult, DuckDBType } from '@duckdb/node-api';\nimport { convertRowsToRecords } from './convert-rows-to-records';\nimport { convertRecordDuckDBValueToJSON } from './duckdb-type-convertor';\n\nexport interface ColumnMetadata {\n  name: string;\n  type: DuckDBType;\n}\n\nexport interface QueryResult {\n  data: Record<string, unknown>[];\n  schema: ColumnMetadata[];\n}\n\n/**\n * Converts raw DuckDB query results into a structured format with named objects\n */\nexport const transformDuckDBQueryResult = async (\n  result: DuckDBResult\n): Promise<QueryResult> => {\n  const columnNames = result.columnNames();\n  const columnTypes = result.columnTypes();\n\n  const columns = columnNames.map((name, index) => ({\n    name,\n    type: columnTypes[index],\n  }));\n\n  const rows = await result.getRows();\n\n  const records = convertRowsToRecords(rows, result.columnNames());\n\n  const data = convertRecordDuckDBValueToJSON(records, columns);\n\n  return { data, schema: columns };\n};\n"],"names":["transformDuckDBQueryResult","result","columnNames","columnTypes","columns","map","name","index","type","rows","getRows","records","convertRowsToRecords","data","convertRecordDuckDBValueToJSON","schema"],"mappings":";+BAiBaA;;;eAAAA;;;sCAhBwB;qCACU;AAexC,MAAMA,6BAA6B,OACxCC;IAEA,MAAMC,cAAcD,OAAOC,WAAW;IACtC,MAAMC,cAAcF,OAAOE,WAAW;IAEtC,MAAMC,UAAUF,YAAYG,GAAG,CAAC,CAACC,MAAMC,QAAW,CAAA;YAChDD;YACAE,MAAML,WAAW,CAACI,MAAM;QAC1B,CAAA;IAEA,MAAME,OAAO,MAAMR,OAAOS,OAAO;IAEjC,MAAMC,UAAUC,IAAAA,0CAAoB,EAACH,MAAMR,OAAOC,WAAW;IAE7D,MAAMW,OAAOC,IAAAA,mDAA8B,EAACH,SAASP;IAErD,OAAO;QAAES;QAAME,QAAQX;IAAQ;AACjC"}