@sqlrooms/duckdb 0.0.3 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqlrooms/duckdb",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -13,8 +13,7 @@
     "url": "https://github.com/sqlrooms/sqlrooms.git"
   },
   "files": [
-    "dist",
-    "!dist/__tests__"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -24,7 +23,7 @@
     "apache-arrow": "^18.1.0"
   },
   "devDependencies": {
-    "@sqlrooms/jest-config": "0.0.3",
+    "@sqlrooms/jest-config": "0.1.0",
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2"
@@ -38,5 +37,5 @@
     "test": "jest",
     "test:watch": "jest --watch"
   },
-  "gitHead": "4269a3efdb5a903cb2498c126e9c36683b3bbae0"
+  "gitHead": "2d44f6636dbd53d18c32a422351e93caa182ada6"
 }