@objectstack/driver-sql 3.2.9

package/src/sql-driver-queryast.test.ts

@@ -0,0 +1,180 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqlDriver } from '../src/index.js';
+
+/**
+ * QueryAST format tests — verifies compatibility with @objectstack/spec QueryAST.
+ */
+describe('SqlDriver (QueryAST Format)', () => {
+  let driver: SqlDriver;
+
+  beforeEach(async () => {
+    driver = new SqlDriver({
+      client: 'better-sqlite3',
+      connection: { filename: ':memory:' },
+      useNullAsDefault: true,
+    });
+
+    const k = (driver as any).knex;
+
+    await k.schema.createTable('products', (t: any) => {
+      t.string('id').primary();
+      t.string('name');
+      t.float('price');
+      t.string('category');
+    });
+
+    await k('products').insert([
+      { id: '1', name: 'Laptop', price: 1200, category: 'Electronics' },
+      { id: '2', name: 'Mouse', price: 25, category: 'Electronics' },
+      { id: '3', name: 'Desk', price: 350, category: 'Furniture' },
+      { id: '4', name: 'Chair', price: 200, category: 'Furniture' },
+      { id: '5', name: 'Monitor', price: 400, category: 'Electronics' },
+    ]);
+  });
+
+  afterEach(async () => {
+    await driver.disconnect();
+  });
+
+  describe('Driver Metadata', () => {
+    it('should expose driver metadata for ObjectStack compatibility', () => {
+      expect(driver.name).toBe('com.objectstack.driver.sql');
+      expect(driver.version).toBeDefined();
+      expect(driver.supports).toBeDefined();
+      expect(driver.supports.transactions).toBe(true);
+      expect(driver.supports.joins).toBe(true);
+    });
+  });
+
+  describe('Lifecycle Methods', () => {
+    it('should support connect method', async () => {
+      await expect(driver.connect()).resolves.toBeUndefined();
+    });
+
+    it('should support checkHealth method', async () => {
+      const healthy = await driver.checkHealth();
+      expect(healthy).toBe(true);
+    });
+
+    it('should support disconnect method', async () => {
+      const testDriver = new SqlDriver({
+        client: 'better-sqlite3',
+        connection: { filename: ':memory:' },
+        useNullAsDefault: true,
+      });
+
+      await expect(testDriver.disconnect()).resolves.toBeUndefined();
+      const healthy = await testDriver.checkHealth();
+      expect(healthy).toBe(false);
+    });
+  });
+
+  describe('QueryAST Format Support', () => {
+    it('should support QueryAST with "top" instead of "limit"', async () => {
+      const results = await driver.find('products', {
+        fields: ['name', 'price'],
+        top: 2,
+        sort: [{ field: 'price', order: 'asc' as const }],
+      } as any);
+
+      expect(results.length).toBe(2);
+      expect(results[0].name).toBe('Mouse');
+      expect(results[1].name).toBe('Chair');
+    });
+
+    it('should support QueryAST sort format with object notation', async () => {
+      const results = await driver.find('products', {
+        fields: ['name'],
+        sort: [
+          { field: 'category', order: 'asc' as const },
+          { field: 'price', order: 'desc' as const },
+        ],
+      } as any);
+
+      expect(results.length).toBe(5);
+      expect(results[0].name).toBe('Laptop');
+      expect(results[3].name).toBe('Desk');
+    });
+
+    it('should support QueryAST with filters and pagination', async () => {
+      const results = await driver.find('products', {
+        filters: [['category', '=', 'Electronics']],
+        skip: 1,
+        top: 1,
+        sort: [{ field: 'price', order: 'asc' as const }],
+      } as any);
+
+      expect(results.length).toBe(1);
+      expect(results[0].name).toBe('Monitor');
+    });
+
+    it('should support aggregations in QueryAST format', async () => {
+      const results = await driver.aggregate('products', {
+        aggregations: [
+          { function: 'sum' as const, field: 'price', alias: 'total_price' },
+          { function: 'count' as const, field: '*', alias: 'count' },
+        ],
+        groupBy: ['category'],
+      });
+
+      expect(results.length).toBe(2);
+
+      const electronics = results.find((r: any) => r.category === 'Electronics');
+      const furniture = results.find((r: any) => r.category === 'Furniture');
+
+      expect(electronics).toBeDefined();
+      expect(electronics.total_price).toBe(1625);
+
+      expect(furniture).toBeDefined();
+      expect(furniture.total_price).toBe(550);
+    });
+
+    it('should support count with QueryAST format', async () => {
+      const count = await driver.count('products', {
+        filters: [['price', '>', 300]],
+      } as any);
+      expect(count).toBe(3);
+    });
+  });
+
+  describe('Backward Compatibility', () => {
+    it('should still support legacy UnifiedQuery format with "limit"', async () => {
+      const results = await driver.find('products', {
+        fields: ['name'],
+        limit: 2,
+        sort: [['price', 'asc']],
+      } as any);
+
+      expect(results.length).toBe(2);
+      expect(results[0].name).toBe('Mouse');
+    });
+
+    it('should still support legacy aggregate format', async () => {
+      const results = await driver.aggregate('products', {
+        aggregate: [{ func: 'avg', field: 'price', alias: 'avg_price' }],
+        groupBy: ['category'],
+      });
+
+      expect(results.length).toBe(2);
+      const electronics = results.find((r: any) => r.category === 'Electronics');
+      expect(electronics.avg_price).toBeCloseTo(541.67, 1);
+    });
+  });
+
+  describe('Mixed Format Support', () => {
+    it('should handle query with both top and skip', async () => {
+      const results = await driver.find('products', {
+        top: 3,
+        skip: 2,
+        sort: [{ field: 'name', order: 'asc' as const }],
+      } as any);
+
+      expect(results.length).toBe(3);
+      expect(results[0].name).toBe('Laptop');
+      expect(results[1].name).toBe('Monitor');
+      expect(results[2].name).toBe('Mouse');
+    });
+  });
+});

package/src/sql-driver-schema.test.ts

@@ -0,0 +1,246 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqlDriver } from '../src/index.js';
+
+describe('SqlDriver Schema Sync (SQLite)', () => {
+  let driver: SqlDriver;
+  let knexInstance: any;
+
+  beforeEach(async () => {
+    driver = new SqlDriver({
+      client: 'better-sqlite3',
+      connection: { filename: ':memory:' },
+      useNullAsDefault: true,
+    });
+    knexInstance = (driver as any).knex;
+  });
+
+  afterEach(async () => {
+    await knexInstance.destroy();
+  });
+
+  it('should create table if not exists', async () => {
+    const objects = [
+      {
+        name: 'test_obj',
+        fields: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    const exists = await knexInstance.schema.hasTable('test_obj');
+    expect(exists).toBe(true);
+
+    const columns = await knexInstance('test_obj').columnInfo();
+    expect(columns).toHaveProperty('id');
+    expect(columns).toHaveProperty('created_at');
+    expect(columns).toHaveProperty('updated_at');
+    expect(columns).toHaveProperty('name');
+    expect(columns).toHaveProperty('age');
+  });
+
+  it('should add new columns if table exists', async () => {
+    await knexInstance.schema.createTable('test_obj', (t: any) => {
+      t.string('id').primary();
+      t.string('name');
+    });
+
+    await knexInstance('test_obj').insert({ id: '1', name: 'Old Data' });
+
+    const objects = [
+      {
+        name: 'test_obj',
+        fields: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+          active: { type: 'boolean' },
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    const columns = await knexInstance('test_obj').columnInfo();
+    expect(columns).toHaveProperty('age');
+    expect(columns).toHaveProperty('active');
+
+    const row = await knexInstance('test_obj').where('id', '1').first();
+    expect(row.name).toBe('Old Data');
+  });
+
+  it('should not delete existing columns', async () => {
+    await knexInstance.schema.createTable('test_obj', (t: any) => {
+      t.string('id').primary();
+      t.string('name');
+      t.string('extra_column');
+    });
+
+    const objects = [
+      {
+        name: 'test_obj',
+        fields: {
+          name: { type: 'string' },
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    const columns = await knexInstance('test_obj').columnInfo();
+    expect(columns).toHaveProperty('name');
+    expect(columns).toHaveProperty('extra_column');
+  });
+
+  it('should not fail if table creation is repeated', async () => {
+    const objects = [
+      {
+        name: 'test_obj',
+        fields: {
+          name: { type: 'string' },
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+    await driver.initObjects(objects);
+
+    const exists = await knexInstance.schema.hasTable('test_obj');
+    expect(exists).toBe(true);
+  });
+
+  it('should create json column for multiple=true fields', async () => {
+    const objects = [
+      {
+        name: 'multi_test',
+        fields: {
+          tags: { type: 'select', multiple: true } as any,
+          users: { type: 'lookup', reference_to: 'user', multiple: true } as any,
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    await driver.create('multi_test', {
+      tags: ['a', 'b'],
+      users: ['u1', 'u2'],
+    });
+
+    const results = await driver.find('multi_test', {});
+    const row = results[0];
+
+    expect(row.tags).toEqual(['a', 'b']);
+    expect(row.users).toEqual(['u1', 'u2']);
+  });
+
+  it('should create percent column', async () => {
+    const objects = [
+      {
+        name: 'percent_test',
+        fields: {
+          completion: { type: 'percent' } as any,
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    const columns = await knexInstance('percent_test').columnInfo();
+    expect(columns).toHaveProperty('completion');
+
+    await driver.create('percent_test', { completion: 0.85 });
+    const res = await driver.find('percent_test', {});
+    expect(res[0].completion).toBe(0.85);
+  });
+
+  it('should handle special fields (formula, summary, auto_number)', async () => {
+    const objects = [
+      {
+        name: 'special_fields_test',
+        fields: {
+          total: { type: 'formula', expression: 'price * qty', data_type: 'number' } as any,
+          child_count: { type: 'summary', summary_object: 'child_obj', summary_type: 'count' } as any,
+          invoice_no: { type: 'auto_number', auto_number_format: 'INV-{0000}' } as any,
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    const columns = await knexInstance('special_fields_test').columnInfo();
+
+    expect(columns).not.toHaveProperty('total');
+    expect(columns).toHaveProperty('child_count');
+    expect(columns).toHaveProperty('invoice_no');
+  });
+
+  it('should create database constraints (unique, required)', async () => {
+    const objects = [
+      {
+        name: 'constraint_test',
+        fields: {
+          unique_field: { type: 'string', unique: true } as any,
+          required_field: { type: 'string', required: true } as any,
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+
+    await driver.create('constraint_test', { unique_field: 'u1', required_field: 'r1' });
+
+    try {
+      await driver.create('constraint_test', { unique_field: 'u1', required_field: 'r2' });
+      expect.unreachable('Should throw error for unique violation');
+    } catch (e: any) {
+      expect(e.message).toMatch(/UNIQUE constraint failed|duplicate key value/);
+    }
+
+    try {
+      await driver.create('constraint_test', { unique_field: 'u2' });
+      expect.unreachable('Should throw error for not null violation');
+    } catch (e: any) {
+      expect(e.message).toMatch(/NOT NULL constraint failed|null value in column/);
+    }
+  });
+
+  it('should handle new field types (email, file, location)', async () => {
+    const objects = [
+      {
+        name: 'new_types_test',
+        fields: {
+          email: { type: 'email' } as any,
+          profile_pic: { type: 'image' } as any,
+          resume: { type: 'file' } as any,
+          office_loc: { type: 'location' } as any,
+          work_hours: { type: 'time' } as any,
+        },
+      },
+    ];
+
+    await driver.initObjects(objects);
+    const cols = await knexInstance('new_types_test').columnInfo();
+
+    expect(cols).toHaveProperty('email');
+    expect(cols).toHaveProperty('profile_pic');
+    expect(cols).toHaveProperty('resume');
+
+    await driver.create('new_types_test', {
+      email: 'test@example.com',
+      profile_pic: { url: 'http://img.com/1.png' },
+      office_loc: { lat: 10, lng: 20 },
+      work_hours: '09:00:00',
+    });
+
+    const res = await driver.find('new_types_test', {});
+    const row = res[0];
+
+    expect(row.email).toBe('test@example.com');
+    expect(row.office_loc).toEqual({ lat: 10, lng: 20 });
+  });
+});

package/src/sql-driver.test.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqlDriver } from '../src/index.js';
+
+describe('SqlDriver (SQLite Integration)', () => {
+  let driver: SqlDriver;
+
+  beforeEach(async () => {
+    driver = new SqlDriver({
+      client: 'better-sqlite3',
+      connection: { filename: ':memory:' },
+      useNullAsDefault: true,
+    });
+
+    const k = (driver as any).knex;
+
+    await k.schema.createTable('users', (t: any) => {
+      t.string('id').primary();
+      t.string('name');
+      t.integer('age');
+    });
+
+    await k('users').insert([
+      { id: '1', name: 'Alice', age: 25 },
+      { id: '2', name: 'Bob', age: 17 },
+      { id: '3', name: 'Charlie', age: 30 },
+      { id: '4', name: 'Dave', age: 17 },
+    ]);
+  });
+
+  afterEach(async () => {
+    await driver.disconnect();
+  });
+
+  it('should be instantiable', () => {
+    expect(driver).toBeDefined();
+    expect(driver).toBeInstanceOf(SqlDriver);
+  });
+
+  it('should find objects with filters', async () => {
+    const results = await driver.find('users', {
+      fields: ['name', 'age'],
+      where: { age: { $gt: 18 } },
+      orderBy: [{ field: 'name', order: 'asc' }],
+    });
+
+    expect(results.length).toBe(2);
+    expect(results.map((r: any) => r.name)).toEqual(['Alice', 'Charlie']);
+  });
+
+  it('should apply simple AND/OR logic', async () => {
+    const results = await driver.find('users', {
+      where: {
+        $or: [{ age: 17 }, { age: { $gt: 29 } }],
+      },
+    });
+    const names = results.map((r: any) => r.name).sort();
+    expect(names).toEqual(['Bob', 'Charlie', 'Dave']);
+  });
+
+  it('should find one object by id', async () => {
+    const [alice] = await driver.find('users', { where: { name: 'Alice' } });
+    expect(alice).toBeDefined();
+
+    const fetched = await driver.findOne('users', alice.id as any);
+    expect(fetched).toBeDefined();
+    expect(fetched.name).toBe('Alice');
+  });
+
+  it('should create an object', async () => {
+    await driver.create('users', { name: 'Eve', age: 22 });
+
+    const [eve] = await driver.find('users', { where: { name: 'Eve' } });
+    expect(eve).toBeDefined();
+    expect(eve.age).toBe(22);
+  });
+
+  it('should update an object', async () => {
+    const [bob] = await driver.find('users', { where: { name: 'Bob' } });
+    await driver.update('users', bob.id, { age: 18 });
+
+    const updated = await driver.findOne('users', bob.id as any);
+    expect(updated.age).toBe(18);
+  });
+
+  it('should delete an object', async () => {
+    const [charlie] = await driver.find('users', { where: { name: 'Charlie' } });
+    await driver.delete('users', charlie.id);
+
+    const deleted = await driver.findOne('users', charlie.id as any);
+    expect(deleted).toBeNull();
+  });
+
+  it('should count objects', async () => {
+    const count = await driver.count('users', { age: 17 } as any);
+    expect(count).toBe(2);
+  });
+
+  it('should map _id to id if provided', async () => {
+    const created = await driver.create('users', { _id: 'custom-id', name: 'Frank', age: 40 });
+
+    expect(created.id).toBe('custom-id');
+    const fetched = await driver.findOne('users', 'custom-id' as any);
+    expect(fetched).toBeDefined();
+    expect(fetched.name).toBe('Frank');
+  });
+});