@devrev/meerkat-node 0.0.89 → 0.0.90

package/package.json

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

package/src/duckdb-exec.d.ts

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

package/src/duckdb-exec.js

@@ -6,13 +6,16 @@ Object.defineProperty(exports, "duckdbExec", {
     }
 });
 const _duckdbsingleton = require("./duckdb-singleton");
-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;
+const duckdbExec = (query)=>{
+    const db = _duckdbsingleton.DuckDBSingleton.getInstance();
+    return new Promise((resolve, reject)=>{
+        db.all(query, (err, res)=>{
+            if (err) {
+                reject(err);
+            }
+            resolve(res);
+        });
+    });
 };
 
 //# 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';\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"}
+{"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"}

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

@@ -1,19 +1,28 @@
-import { DuckDBInstance } from '@duckdb/node-api';
-import { QueryResult } from '../utils/transform-duckdb-result';
+import { ColumnInfo, Connection, Database, TableData } from 'duckdb';
 export declare class DuckDBManager {
     private db;
     private connection;
     private initPromise;
-    constructor({ initializeDatabase, }: {
-        initializeDatabase?: (db: DuckDBInstance) => Promise<void>;
+    constructor({ onInitialize, }: {
+        onInitialize?: (db: Database) => Promise<void>;
     });
     /**
      * Initialize the DuckDB instance
      */
     private initialize;
-    private getConnection;
+    /**
+     * Get a DuckDB connection instance.
+     */
+    getConnection(): Promise<Connection | null>;
     /**
      * Execute a query on the DuckDB connection.
      */
-    query(query: string): Promise<QueryResult>;
+    query(query: string): Promise<{
+        columns: ColumnInfo[];
+        data: TableData;
+    }>;
+    /**
+     * Close the DuckDB connection and cleanup resources.
+     */
+    close(): Promise<void>;
 }

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

@@ -6,20 +6,23 @@ Object.defineProperty(exports, "DuckDBManager", {
     }
 });
 const _duckdbsingleton = require("../duckdb-singleton");
-const _transformduckdbresult = require("../utils/transform-duckdb-result");
+const _duckdbtypeconvertor = require("../utils/duckdb-type-convertor");
 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 initialize({ onInitialize }) {
+        this.db = _duckdbsingleton.DuckDBSingleton.getInstance();
+        await (onInitialize == null ? void 0 : onInitialize(this.db));
     }
-    async getConnection() {
+    /**
+   * Get a DuckDB connection instance.
+   */ async getConnection() {
+        // Ensure database is initialized before returning the connection
         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;
+            var _this_db_connect;
+            this.connection = (_this_db_connect = (_this_db = this.db) == null ? void 0 : _this_db.connect()) != null ? _this_db_connect : null;
         }
         return this.connection;
     }
@@ -27,16 +30,40 @@ let DuckDBManager = class DuckDBManager {
    * 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;
+        return new Promise((resolve, reject)=>{
+            connection == null ? void 0 : connection.prepare(query, (err, statement)=>{
+                if (err) {
+                    reject(new Error(`Query preparation failed: ${err.message}`));
+                    return;
+                }
+                const columns = statement.columns();
+                statement.all((err, data)=>{
+                    if (err) {
+                        reject(new Error(`Query execution failed: ${err.message}`));
+                        return;
+                    }
+                    const result = (0, _duckdbtypeconvertor.convertTableDataToJSON)(data, columns);
+                    resolve({
+                        columns,
+                        data: result
+                    });
+                });
+            });
+        });
+    }
+    /**
+   * Close the DuckDB connection and cleanup resources.
+   */ async close() {
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+        }
     }
-    constructor({ initializeDatabase }){
+    constructor({ onInitialize }){
         this.db = null;
         this.connection = null;
         this.initPromise = this.initialize({
-            initializeDatabase
+            onInitialize
         });
     }
 };

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

@@ -1 +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"}
+{"version":3,"sources":["../../../../meerkat-node/src/duckdb-manager/duckdb-manager.ts"],"sourcesContent":["import { ColumnInfo, Connection, Database, TableData } from 'duckdb';\n\nimport { DuckDBSingleton } from '../duckdb-singleton';\nimport { convertTableDataToJSON } from '../utils/duckdb-type-convertor';\n\nexport class DuckDBManager {\n  private db: Database | null = null;\n  private connection: Connection | null = null;\n\n  private initPromise: Promise<void>;\n\n  constructor({\n    onInitialize,\n  }: {\n    onInitialize?: (db: Database) => Promise<void>;\n  }) {\n    this.initPromise = this.initialize({ onInitialize });\n  }\n\n  /**\n   * Initialize the DuckDB instance\n   */\n  private async initialize({\n    onInitialize,\n  }: {\n    onInitialize?: (db: Database) => Promise<void>;\n  }) {\n    this.db = DuckDBSingleton.getInstance();\n\n    await onInitialize?.(this.db);\n  }\n\n  /**\n   * Get a DuckDB connection instance.\n   */\n  async getConnection() {\n    // Ensure database is initialized before returning the connection\n    await this.initPromise;\n\n    if (!this.connection) {\n      this.connection = 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(\n    query: string\n  ): Promise<{ columns: ColumnInfo[]; data: TableData }> {\n    const connection = await this.getConnection();\n\n    return new Promise((resolve, reject) => {\n      connection?.prepare(query, (err, statement) => {\n        if (err) {\n          reject(new Error(`Query preparation failed: ${err.message}`));\n          return;\n        }\n\n        const columns = statement.columns();\n\n        statement.all((err, data) => {\n          if (err) {\n            reject(new Error(`Query execution failed: ${err.message}`));\n            return;\n          }\n\n          const result = convertTableDataToJSON(data, columns);\n\n          resolve({ columns, data: result });\n        });\n      });\n    });\n  }\n\n  /**\n   * Close the DuckDB connection and cleanup resources.\n   */\n  async close(): Promise<void> {\n    if (this.connection) {\n      this.connection.close();\n      this.connection = null;\n    }\n  }\n}\n"],"names":["DuckDBManager","initialize","onInitialize","db","DuckDBSingleton","getInstance","getConnection","initPromise","connection","connect","query","Promise","resolve","reject","prepare","err","statement","Error","message","columns","all","data","result","convertTableDataToJSON","close","constructor"],"mappings":";+BAKaA;;;eAAAA;;;iCAHmB;qCACO;AAEhC,IAAA,AAAMA,gBAAN,MAAMA;IAcX;;GAEC,GACD,MAAcC,WAAW,EACvBC,YAAY,EAGb,EAAE;QACD,IAAI,CAACC,EAAE,GAAGC,gCAAe,CAACC,WAAW;QAErC,OAAMH,gCAAAA,aAAe,IAAI,CAACC,EAAE;IAC9B;IAEA;;GAEC,GACD,MAAMG,gBAAgB;QACpB,iEAAiE;QACjE,MAAM,IAAI,CAACC,WAAW;QAEtB,IAAI,CAAC,IAAI,CAACC,UAAU,EAAE;gBACF;gBAAA;YAAlB,IAAI,CAACA,UAAU,GAAG,CAAA,oBAAA,WAAA,IAAI,CAACL,EAAE,qBAAP,SAASM,OAAO,cAAhB,mBAAsB;QAC1C;QAEA,OAAO,IAAI,CAACD,UAAU;IACxB;IAEA;;GAEC,GACD,MAAME,MACJA,KAAa,EACwC;QACrD,MAAMF,aAAa,MAAM,IAAI,CAACF,aAAa;QAE3C,OAAO,IAAIK,QAAQ,CAACC,SAASC;YAC3BL,8BAAAA,WAAYM,OAAO,CAACJ,OAAO,CAACK,KAAKC;gBAC/B,IAAID,KAAK;oBACPF,OAAO,IAAII,MAAM,CAAC,0BAA0B,EAAEF,IAAIG,OAAO,CAAC,CAAC;oBAC3D;gBACF;gBAEA,MAAMC,UAAUH,UAAUG,OAAO;gBAEjCH,UAAUI,GAAG,CAAC,CAACL,KAAKM;oBAClB,IAAIN,KAAK;wBACPF,OAAO,IAAII,MAAM,CAAC,wBAAwB,EAAEF,IAAIG,OAAO,CAAC,CAAC;wBACzD;oBACF;oBAEA,MAAMI,SAASC,IAAAA,2CAAsB,EAACF,MAAMF;oBAE5CP,QAAQ;wBAAEO;wBAASE,MAAMC;oBAAO;gBAClC;YACF;QACF;IACF;IAEA;;GAEC,GACD,MAAME,QAAuB;QAC3B,IAAI,IAAI,CAAChB,UAAU,EAAE;YACnB,IAAI,CAACA,UAAU,CAACgB,KAAK;YACrB,IAAI,CAAChB,UAAU,GAAG;QACpB;IACF;IA1EAiB,YAAY,EACVvB,YAAY,EAGb,CAAE;aATKC,KAAsB;aACtBK,aAAgC;QAStC,IAAI,CAACD,WAAW,GAAG,IAAI,CAACN,UAAU,CAAC;YAAEC;QAAa;IACpD;AAqEF"}

package/src/duckdb-singleton.d.ts

@@ -1,4 +1,4 @@
-import { DuckDBInstance } from '@duckdb/node-api';
+import { Database } from 'duckdb';
 /**
  * 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 { DuckDBInstance } from '@duckdb/node-api';
 export declare class DuckDBSingleton {
     private static instance;
     private constructor();
-    static getInstance(): Promise<DuckDBInstance>;
+    static getInstance(): Database;
 }

package/src/duckdb-singleton.js

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

package/src/duckdb-singleton.js.map

@@ -1 +1 @@
-{"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"}
+{"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"}

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

@@ -4,6 +4,7 @@ export declare class FileManager {
         baseDir?: string;
     });
     getPath(tableName: string, fileName?: string): string;
+    private getHashedFileName;
     /**
      * Write a file buffer to the file system.
      */

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

@@ -9,16 +9,19 @@ const _extends = require("@swc/helpers/_/_extends");
 const _axios = require("axios");
 const _fs = require("fs");
 const _path = require("path");
-const _encryptstring = require("../utils/encrypt-string");
+const _hashstring = require("../utils/hash-string");
 let FileManager = class FileManager {
     getPath(tableName, fileName) {
         return fileName ? _path.join(this.baseDir, tableName, fileName) : _path.join(this.baseDir, tableName);
     }
+    getHashedFileName(fileName) {
+        return (0, _hashstring.hashString)(fileName);
+    }
     /**
    * 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 hashedFileName = this.getHashedFileName(file.fileName);
         const filePath = this.getPath(file.tableName, hashedFileName);
         await _fs.promises.mkdir(_path.dirname(filePath), {
             recursive: true
@@ -40,7 +43,7 @@ let FileManager = class FileManager {
    */ async deleteTableFiles(tableName, files) {
         await Promise.all(files.map(async (file)=>{
             try {
-                await _fs.promises.unlink(this.getPath(tableName, file));
+                await _fs.promises.unlink(this.getPath(tableName, this.getHashedFileName(file)));
             } catch (err) {
                 console.error(err);
             }
@@ -56,7 +59,7 @@ let FileManager = class FileManager {
                 responseType: 'stream',
                 url
             });
-            const hashedFileName = (0, _encryptstring.encryptString)(fileName);
+            const hashedFileName = (0, _hashstring.hashString)(fileName);
             const filePath = this.getPath(tableName, hashedFileName);
             await _fs.promises.mkdir(_path.dirname(filePath), {
                 recursive: true

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

@@ -1 +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"}
+{"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 { hashString } from '../utils/hash-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  private getHashedFileName(fileName: string): string {\n    return hashString(fileName);\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 = this.getHashedFileName(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(\n            this.getPath(tableName, this.getHashedFileName(file))\n          );\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 = hashString(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","getHashedFileName","hashString","writeFileBuffer","file","hashedFileName","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;4BAEK;AAEpB,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;IAEQK,kBAAkBJ,QAAgB,EAAU;QAClD,OAAOK,IAAAA,sBAAU,EAACL;IACpB;IAEA;;GAEC,GACD,MAAMM,gBAAgBC,IAIrB,EAAiB;QAChB,sDAAsD;QACtD,MAAMC,iBAAiB,IAAI,CAACJ,iBAAiB,CAACG,KAAKP,QAAQ;QAE3D,MAAMS,WAAW,IAAI,CAACX,OAAO,CAACS,KAAKR,SAAS,EAAES;QAE9C,MAAME,YAAE,CAACC,KAAK,CAACV,MAAKW,OAAO,CAACH,WAAW;YAAEI,WAAW;QAAK;QAEzD,MAAMH,YAAE,CAACI,SAAS,CAACL,UAAUF,KAAKQ,MAAM;IAC1C;IAEA;;GAEC,GACD,MAAMC,kBAAkBjB,SAAiB,EAAqB;QAC5D,IAAI;YACF,MAAMkB,QAAQ,MAAMP,YAAE,CAACQ,OAAO,CAAC,IAAI,CAACpB,OAAO,CAACC;YAE5C,OAAOkB,MAAME,GAAG,CAAC,CAACZ,OAAS,IAAI,CAACT,OAAO,CAACC,WAAWQ;QACrD,EAAE,UAAM;YACN,OAAO,EAAE;QACX;IACF;IAEA;;GAEC,GACD,MAAMa,iBAAiBrB,SAAiB,EAAEkB,KAAe,EAAiB;QACxE,MAAMI,QAAQC,GAAG,CACfL,MAAME,GAAG,CAAC,OAAOZ;YACf,IAAI;gBACF,MAAMG,YAAE,CAACa,MAAM,CACb,IAAI,CAACzB,OAAO,CAACC,WAAW,IAAI,CAACK,iBAAiB,CAACG;YAEnD,EAAE,OAAOiB,KAAK;gBACZC,QAAQC,KAAK,CAACF;YAChB;QACF;IAEJ;IAEA;;GAEC,GACD,MAAMG,sBAAsB,EAC1B5B,SAAS,EACT6B,GAAG,EACHC,OAAO,EACP7B,QAAQ,EAMT,EAAiB;QAChB,IAAI;YACF,MAAM8B,WAAW,MAAMC,IAAAA,cAAK,EAAC;gBAC3BF,SAAS,eACJA;gBAELG,QAAQ;gBACRC,cAAc;gBACdL;YACF;YAEA,MAAMpB,iBAAiBH,IAAAA,sBAAU,EAACL;YAElC,MAAMS,WAAW,IAAI,CAACX,OAAO,CAACC,WAAWS;YACzC,MAAME,YAAE,CAACC,KAAK,CAACV,MAAKW,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;IA7GAgB,YAAYC,MAA4B,CAAE;YACzBA;QAAf,IAAI,CAACxC,OAAO,GAAGwC,CAAAA,kBAAAA,OAAOxC,OAAO,YAAdwC,kBAAkB;QACjCjC,YAAE,CAACC,KAAK,CAAC,IAAI,CAACR,OAAO,EAAE;YAAEU,WAAW;QAAK,GAAG+B,KAAK,CAACnB,QAAQC,KAAK;IACjE;AA2GF"}

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(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"}
+{"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 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,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;QAIpD;IACF;IACA,OAAOD;AACT"}

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

@@ -1,6 +1,3 @@
-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>[];
+import { ColumnInfo, TableData, TypeInfo } from 'duckdb';
+export declare const convertDuckDBValueToJS: (field: TypeInfo, value: unknown) => unknown;
+export declare const convertTableDataToJSON: (data: TableData, columns: ColumnInfo[]) => Record<string, unknown>[];

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

@@ -9,47 +9,47 @@ _export(exports, {
     convertDuckDBValueToJS: function() {
         return convertDuckDBValueToJS;
     },
-    convertRecordDuckDBValueToJSON: function() {
-        return convertRecordDuckDBValueToJSON;
+    convertTableDataToJSON: function() {
+        return convertTableDataToJSON;
     }
 });
-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:
+    if ((0, _lodash.isNil)(value)) return null;
+    switch(field.id){
+        case 'SQL_NULL':
             return null;
-        case _nodeapi.DuckDBTypeId.DATE:
-        case _nodeapi.DuckDBTypeId.TIMESTAMP:
-        case _nodeapi.DuckDBTypeId.TIME:
+        case 'DATE':
+        case 'TIME':
+        case 'TIMESTAMP':
             return new Date(value).toISOString();
-        case _nodeapi.DuckDBTypeId.FLOAT:
-        case _nodeapi.DuckDBTypeId.DOUBLE:
+        case 'FLOAT':
+        case '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:
+        case 'INTEGER':
+        case 'TINYINT':
+        case 'SMALLINT':
+        case 'BIGINT':
+        case 'UTINYINT':
+        case 'USMALLINT':
+        case 'UINTEGER':
+        case 'UBIGINT':
+        case 'HUGEINT':
+        case 'UHUGEINT':
+            return parseInt(value.toString(), 10);
+        case 'DECIMAL':
             return parseFloat(value.toString());
-        case _nodeapi.DuckDBTypeId.LIST:
+        case 'LIST':
             {
                 if (!value) return [];
                 const listValue = value;
-                return listValue.items.map((item)=>convertDuckDBValueToJS(field.valueType, item));
+                return listValue.map((item)=>convertDuckDBValueToJS(field.child, item));
             }
         default:
             return value;
     }
 };
-const convertRecordDuckDBValueToJSON = (data, columns)=>{
-    console.log(data);
+const convertTableDataToJSON = (data, columns)=>{
     return data.map((row)=>{
         return columns.reduce((acc, column)=>{
             acc[column.name] = convertDuckDBValueToJS(column.type, row[column.name]);

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

@@ -1 +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"}
+{"version":3,"sources":["../../../../meerkat-node/src/utils/duckdb-type-convertor.ts"],"sourcesContent":["import { ColumnInfo, ListTypeInfo, TableData, TypeInfo } from 'duckdb';\nimport { isNil } from 'lodash';\n\nexport const convertDuckDBValueToJS = (\n  field: TypeInfo,\n  value: unknown\n): unknown => {\n  if (isNil(value)) return null;\n\n  switch (field.id) {\n    case 'SQL_NULL':\n      return null;\n    case 'DATE':\n    case 'TIME':\n    case 'TIMESTAMP':\n      return new Date(value as string).toISOString();\n    case 'FLOAT':\n    case 'DOUBLE':\n      return value;\n    case 'INTEGER':\n    case 'TINYINT':\n    case 'SMALLINT':\n    case 'BIGINT':\n    case 'UTINYINT':\n    case 'USMALLINT':\n    case 'UINTEGER':\n    case 'UBIGINT':\n    case 'HUGEINT':\n    case 'UHUGEINT':\n      return parseInt((value as object).toString(), 10);\n    case 'DECIMAL':\n      return parseFloat((value as object).toString());\n    case 'LIST': {\n      if (!value) return [];\n      const listValue = value as [];\n      return listValue.map((item) =>\n        convertDuckDBValueToJS((field as ListTypeInfo).child, item)\n      );\n    }\n    default:\n      return value;\n  }\n};\n\nexport const convertTableDataToJSON = (\n  data: TableData,\n  columns: ColumnInfo[]\n): Record<string, unknown>[] => {\n  return data.map((row: Record<string, unknown>) => {\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","convertTableDataToJSON","field","value","isNil","id","Date","toISOString","parseInt","toString","parseFloat","listValue","map","item","child","data","columns","row","reduce","acc","column","name","type"],"mappings":";;;;;;;;IAGaA,sBAAsB;eAAtBA;;IAyCAC,sBAAsB;eAAtBA;;;wBA3CS;AAEf,MAAMD,yBAAyB,CACpCE,OACAC;IAEA,IAAIC,IAAAA,aAAK,EAACD,QAAQ,OAAO;IAEzB,OAAQD,MAAMG,EAAE;QACd,KAAK;YACH,OAAO;QACT,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAO,IAAIC,KAAKH,OAAiBI,WAAW;QAC9C,KAAK;QACL,KAAK;YACH,OAAOJ;QACT,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAOK,SAAS,AAACL,MAAiBM,QAAQ,IAAI;QAChD,KAAK;YACH,OAAOC,WAAW,AAACP,MAAiBM,QAAQ;QAC9C,KAAK;YAAQ;gBACX,IAAI,CAACN,OAAO,OAAO,EAAE;gBACrB,MAAMQ,YAAYR;gBAClB,OAAOQ,UAAUC,GAAG,CAAC,CAACC,OACpBb,uBAAuB,AAACE,MAAuBY,KAAK,EAAED;YAE1D;QACA;YACE,OAAOV;IACX;AACF;AAEO,MAAMF,yBAAyB,CACpCc,MACAC;IAEA,OAAOD,KAAKH,GAAG,CAAC,CAACK;QACf,OAAOD,QAAQE,MAAM,CAAC,CAACC,KAAKC;YAC1BD,GAAG,CAACC,OAAOC,IAAI,CAAC,GAAGrB,uBAAuBoB,OAAOE,IAAI,EAAEL,GAAG,CAACG,OAAOC,IAAI,CAAC;YACvE,OAAOF;QACT,GAAG,CAAC;IACN;AACF"}

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

@@ -0,0 +1,4 @@
+/**
+ * Hash a string using MD5.
+ */
+export declare const hashString: (text: string) => string;

package/src/utils/hash-string.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "hashString", {
+    enumerable: true,
+    get: function() {
+        return hashString;
+    }
+});
+const _crypto = require("crypto");
+const hashString = (text)=>{
+    return _crypto.createHash('md5').update(text).digest('hex');
+};
+
+//# sourceMappingURL=hash-string.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-node/src/utils/hash-string.ts"],"sourcesContent":["import * as crypto from 'crypto';\n\n/**\n * Hash a string using MD5.\n */\nexport const hashString = (text: string): string => {\n  return crypto.createHash('md5').update(text).digest('hex');\n};\n"],"names":["hashString","text","crypto","createHash","update","digest"],"mappings":";+BAKaA;;;eAAAA;;;wBALW;AAKjB,MAAMA,aAAa,CAACC;IACzB,OAAOC,QAAOC,UAAU,CAAC,OAAOC,MAAM,CAACH,MAAMI,MAAM,CAAC;AACtD"}

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

@@ -1,2 +0,0 @@
-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

@@ -1,17 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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/encrypt-string.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,39 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1,26 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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"}