@sqlrooms/duckdb 0.0.2 → 0.1.0

package/dist/__tests__/arrow-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=arrow-utils.test.d.ts.map

package/dist/__tests__/arrow-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-utils.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/arrow-utils.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/arrow-utils.test.js

@@ -0,0 +1,186 @@
+import * as arrow from 'apache-arrow';
+import { arrowTableToJson } from '../arrow-utils';
+/// TODO: Revise tests for nested objects once https://github.com/apache/arrow/issues/33394 is fixed
+describe('arrow-utils', () => {
+    describe('arrowTableToJson', () => {
+        it('should convert Arrow table to JSON array', () => {
+            // Create a simple Arrow table
+            const data = [
+                { id: 1n, name: 'John', score: 95.5 },
+                { id: 2n, name: 'Jane', score: 88.0 },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            const expected = [
+                { id: 1, name: 'John', score: 95.5 },
+                { id: 2, name: 'Jane', score: 88.0 },
+            ];
+            expect(result).toEqual(expected);
+        });
+        it('should handle large BigInt values', () => {
+            const largeNumber = 9007199254740991n; // Number.MAX_SAFE_INTEGER
+            const data = [
+                { id: largeNumber, value: 'test' },
+                { id: largeNumber + 1n, value: 'test2' },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            const expected = [
+                { id: 9007199254740991, value: 'test' },
+                { id: '9007199254740992', value: 'test2' }, // Beyond MAX_SAFE_INTEGER, should be string
+            ];
+            expect(result).toEqual(expected);
+        });
+        it('should handle timestamps and dates', () => {
+            const timestamp = new Date('2024-02-05T12:30:45.123Z');
+            const date = new Date('2024-02-05');
+            const data = [
+                {
+                    id: 1,
+                    timestamp: timestamp,
+                    date: date,
+                },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            expect(result).toEqual([
+                {
+                    id: 1,
+                    timestamp: timestamp.getTime(),
+                    date: date.getTime(),
+                },
+            ]);
+        });
+        it('should handle nested objects (structs)', () => {
+            /// TODO: Revise tests for nested objects once https://github.com/apache/arrow/issues/33394 is fixed
+            // For now, we'll use JSON strings for nested objects as Arrow's JS API
+            // doesn't seem to have a straightforward way to create struct types
+            const data = [
+                {
+                    id: 1,
+                    user: JSON.stringify({
+                        name: 'John',
+                        address: {
+                            city: 'New York',
+                            country: 'USA',
+                        },
+                    }),
+                },
+                {
+                    id: 2,
+                    user: JSON.stringify({
+                        name: 'Jane',
+                        address: {
+                            city: 'London',
+                            country: 'UK',
+                        },
+                    }),
+                },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            // Parse the JSON strings back to objects for comparison
+            const parsedResult = result.map((row) => ({
+                ...row,
+                user: JSON.parse(row.user),
+            }));
+            expect(parsedResult).toEqual([
+                {
+                    id: 1,
+                    user: {
+                        name: 'John',
+                        address: {
+                            city: 'New York',
+                            country: 'USA',
+                        },
+                    },
+                },
+                {
+                    id: 2,
+                    user: {
+                        name: 'Jane',
+                        address: {
+                            city: 'London',
+                            country: 'UK',
+                        },
+                    },
+                },
+            ]);
+        });
+        it('should handle arrays', () => {
+            // For now, we'll use JSON strings for arrays as Arrow's JS API
+            // doesn't seem to have a straightforward way to create list types
+            const data = [
+                {
+                    id: 1,
+                    tags: JSON.stringify(['a', 'b']),
+                    scores: JSON.stringify([1, 2, 3]),
+                },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            // Parse the JSON strings back to arrays for comparison
+            const parsedResult = result.map((row) => ({
+                ...row,
+                tags: JSON.parse(row.tags),
+                scores: JSON.parse(row.scores),
+            }));
+            expect(parsedResult).toEqual([
+                {
+                    id: 1,
+                    tags: ['a', 'b'],
+                    scores: [1, 2, 3],
+                },
+            ]);
+        });
+        it('should handle combination of structs, BigInts, and timestamps', () => {
+            const timestamp = new Date('2024-02-05T12:30:45.123Z');
+            // const largeNumber = 9007199254740991n; // MAX_SAFE_INTEGER
+            const largeNumber = 1;
+            // Create data with JSON strings for complex structures
+            const data = [
+                {
+                    id: largeNumber,
+                    created_at: timestamp,
+                    metadata: JSON.stringify({
+                        user: {
+                            id: largeNumber, // + 1n,
+                            name: 'John',
+                            last_login: new Date('2024-01-01T00:00:00Z').getTime(),
+                            stats: {
+                                score: 95.5,
+                                rank: largeNumber, // + 2n,
+                            },
+                        },
+                        tags: ['active', 'premium'],
+                    }),
+                },
+            ];
+            const table = arrow.tableFromJSON(data);
+            const result = arrowTableToJson(table);
+            // Parse the JSON strings back to objects for comparison
+            const parsedResult = result.map((row) => ({
+                ...row,
+                metadata: JSON.parse(row.metadata),
+            }));
+            expect(parsedResult).toEqual([
+                {
+                    id: 1,
+                    created_at: timestamp.getTime(),
+                    metadata: {
+                        user: {
+                            id: 1,
+                            name: 'John',
+                            last_login: new Date('2024-01-01T00:00:00Z').getTime(),
+                            stats: {
+                                score: 95.5,
+                                rank: 1,
+                            },
+                        },
+                        tags: ['active', 'premium'],
+                    },
+                },
+            ]);
+        });
+    });
+});

package/dist/__tests__/sql-from.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sql-from.test.d.ts.map

package/dist/__tests__/sql-from.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-from.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/sql-from.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/sql-from.test.js

@@ -0,0 +1,70 @@
+import { sqlFrom, literalToSQL } from '../sql-from';
+describe('sql-from', () => {
+    describe('literalToSQL', () => {
+        it('should convert numbers correctly', () => {
+            expect(literalToSQL(42)).toBe('42');
+            expect(literalToSQL(3.14)).toBe('3.14');
+            expect(literalToSQL(Infinity)).toBe('NULL');
+            expect(literalToSQL(NaN)).toBe('NULL');
+        });
+        it('should convert strings correctly', () => {
+            expect(literalToSQL('hello')).toBe("'hello'");
+            expect(literalToSQL("O'Neil")).toBe("'O''Neil'"); // Escapes single quotes
+        });
+        it('should convert booleans correctly', () => {
+            expect(literalToSQL(true)).toBe('TRUE');
+            expect(literalToSQL(false)).toBe('FALSE');
+        });
+        it('should convert dates correctly', () => {
+            const date = new Date('2024-02-05');
+            expect(literalToSQL(date)).toMatch(/^DATE '\d{4}-\d{1,2}-\d{1,2}'$/);
+            const timestamp = new Date('2024-02-05T12:30:00Z');
+            expect(literalToSQL(timestamp)).toMatch(/^epoch_ms\(\d+\)$/);
+        });
+        it('should handle null and undefined', () => {
+            expect(literalToSQL(null)).toBe('NULL');
+            expect(literalToSQL(undefined)).toBe('NULL');
+        });
+        it('should convert RegExp to string', () => {
+            expect(literalToSQL(/test/)).toBe("'test'");
+        });
+    });
+    describe('sqlFrom', () => {
+        it('should create SQL query from array of objects', () => {
+            const data = [
+                { id: 1, name: 'John' },
+                { id: 2, name: 'Jane' },
+            ];
+            const result = sqlFrom(data);
+            expect(result).toBe('(SELECT 1 AS "id", \'John\' AS "name") ' +
+                'UNION ALL ' +
+                '(SELECT 2 AS "id", \'Jane\' AS "name")');
+        });
+        it('should handle custom column mapping', () => {
+            const data = [
+                { id: 1, firstName: 'John' },
+                { id: 2, firstName: 'Jane' },
+            ];
+            const result = sqlFrom(data, {
+                columns: { id: 'user_id', firstName: 'name' },
+            });
+            expect(result).toBe('(SELECT 1 AS "user_id", \'John\' AS "name") ' +
+                'UNION ALL ' +
+                '(SELECT 2 AS "user_id", \'Jane\' AS "name")');
+        });
+        it('should handle column subset selection', () => {
+            const data = [
+                { id: 1, name: 'John', age: 30 },
+                { id: 2, name: 'Jane', age: 25 },
+            ];
+            const result = sqlFrom(data, { columns: ['id', 'name'] });
+            expect(result).toBe('(SELECT 1 AS "id", \'John\' AS "name") ' +
+                'UNION ALL ' +
+                '(SELECT 2 AS "id", \'Jane\' AS "name")');
+        });
+        it('should throw error for empty column set', () => {
+            const data = [];
+            expect(() => sqlFrom(data)).toThrow('Can not create table from empty column set.');
+        });
+    });
+});

package/dist/arrow-utils.d.ts

@@ -0,0 +1,8 @@
+import * as arrow from 'apache-arrow';
+/**
+ * Converts an Arrow table to a JSON-compatible array of objects
+ * @see https://duckdb.org/docs/api/wasm/query.html#arrow-table-to-json
+ * @see https://github.com/apache/arrow/issues/37856
+ */
+export declare function arrowTableToJson(table: arrow.Table): Record<string, unknown>[];
+//# sourceMappingURL=arrow-utils.d.ts.map

package/dist/arrow-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-utils.d.ts","sourceRoot":"","sources":["../src/arrow-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}

package/dist/arrow-utils.js

@@ -0,0 +1,22 @@
+/**
+ * Converts an Arrow table to a JSON-compatible array of objects
+ * @see https://duckdb.org/docs/api/wasm/query.html#arrow-table-to-json
+ * @see https://github.com/apache/arrow/issues/37856
+ */
+export function arrowTableToJson(table) {
+    return table.toArray().map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => {
+        return [key, convertValue(value)];
+    })));
+}
+function convertValue(value) {
+    if (typeof value === 'bigint') {
+        if (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER) {
+            return Number(value);
+        }
+        return String(value);
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from './duckdb';
 export * from './types';
 export * from './useDuckDb';
 export * from './exportToCsv';
+export * from './arrow-utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './duckdb';
 export * from './types';
 export * from './useDuckDb';
 export * from './exportToCsv';
+export * from './arrow-utils';

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "@sqlrooms/duckdb",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
   "type": "module",
   "private": false,
+  "author": "Ilya Boyandin <ilya@boyandin.me>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sqlrooms/sqlrooms.git"
+  },
   "files": [
     "dist"
   ],
@@ -16,12 +22,20 @@
     "@duckdb/duckdb-wasm": "^1.29.0",
     "apache-arrow": "^18.1.0"
   },
+  "devDependencies": {
+    "@sqlrooms/jest-config": "0.1.0",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
   "scripts": {
     "dev": "tsc -w",
     "build": "tsc",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
-    "typedoc": "typedoc"
+    "typedoc": "typedoc",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
-  "gitHead": "32da0b35fe906bdcef42274624d069cc49425a74"
+  "gitHead": "2d44f6636dbd53d18c32a422351e93caa182ada6"
 }