@objectstack/driver-sql 4.0.4 → 4.1.0

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

@@ -1,243 +0,0 @@
-// 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 limit and orderBy', async () => {
-      const results = await driver.find('products', {
-        fields: ['name', 'price'],
-        limit: 2,
-        orderBy: [{ 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 orderBy with object notation', async () => {
-      const results = await driver.find('products', {
-        fields: ['name'],
-        orderBy: [
-          { 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 where, offset, limit, and orderBy', async () => {
-      const results = await driver.find('products', {
-        where: [['category', '=', 'Electronics']],
-        offset: 1,
-        limit: 1,
-        orderBy: [{ 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 where clause', async () => {
-      const count = await driver.count('products', {
-        where: [['price', '>', 300]],
-      } as any);
-      expect(count).toBe(3);
-    });
-  });
-
-  describe('Standard QueryAST Pagination', () => {
-    it('should support limit with orderBy using standard keys', async () => {
-      const results = await driver.find('products', {
-        fields: ['name'],
-        limit: 2,
-        orderBy: [{ field: 'price', order: '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);
-    });
-
-    it('should support offset and limit with orderBy', async () => {
-      const results = await driver.find('products', {
-        limit: 3,
-        offset: 2,
-        orderBy: [{ 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');
-    });
-  });
-
-  describe('Legacy Keys Are Ignored', () => {
-    it('should ignore legacy "filters" key — only "where" is recognized', async () => {
-      const results = await driver.find('products', {
-        filters: [['category', '=', 'Furniture']],
-      } as any);
-
-      // "filters" is not recognized, so no WHERE clause is applied — returns all rows
-      expect(results.length).toBe(5);
-    });
-
-    it('should use "where" and ignore "filters" when both are present', async () => {
-      const results = await driver.find('products', {
-        where: [['category', '=', 'Electronics']],
-        filters: [['category', '=', 'Furniture']],
-      } as any);
-
-      // Only "where" is applied — returns Electronics, not Furniture
-      expect(results.every((r: any) => r.category === 'Electronics')).toBe(true);
-      expect(results.length).toBe(3);
-    });
-
-    it('should ignore legacy "sort" key — only "orderBy" is recognized', async () => {
-      const results = await driver.find('products', {
-        fields: ['name'],
-        limit: 5,
-        orderBy: [{ field: 'price', order: 'desc' as const }],
-        sort: [{ field: 'price', order: 'asc' as const }],
-      } as any);
-
-      // "sort" is ignored; "orderBy" (desc) is applied — most expensive first
-      expect(results.length).toBe(5);
-      expect(results[0].name).toBe('Laptop');
-      expect(results[4].name).toBe('Mouse');
-    });
-
-    it('should ignore legacy "skip" key — only "offset" is recognized', async () => {
-      const results = await driver.find('products', {
-        skip: 3,
-        orderBy: [{ field: 'name', order: 'asc' as const }],
-      } as any);
-
-      // "skip" is not recognized — no offset applied, returns all 5 rows
-      expect(results.length).toBe(5);
-    });
-
-    it('should ignore legacy "top" key — only "limit" is recognized', async () => {
-      const results = await driver.find('products', {
-        top: 2,
-        orderBy: [{ field: 'name', order: 'asc' as const }],
-      } as any);
-
-      // "top" is not recognized — no limit applied, returns all 5 rows
-      expect(results.length).toBe(5);
-    });
-
-    it('should ignore legacy "filters" in count — only "where" is recognized', async () => {
-      const count = await driver.count('products', {
-        filters: [['price', '>', 300]],
-      } as any);
-
-      // "filters" is not recognized — counts all rows
-      expect(count).toBe(5);
-    });
-  });
-});

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

@@ -1,313 +0,0 @@
-// 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 });
-  });
-
-  it('should skip ensureDatabaseExists for SQLite (no-op)', async () => {
-    // SQLite auto-creates database files, so ensureDatabaseExists should be a no-op
-    // This test verifies that initObjects works normally for SQLite without errors
-    const objects = [
-      {
-        name: 'db_check_test',
-        fields: {
-          value: { type: 'string' },
-        },
-      },
-    ];
-
-    // Should not throw — SQLite skips ensureDatabaseExists
-    await driver.initObjects(objects);
-
-    const exists = await knexInstance.schema.hasTable('db_check_test');
-    expect(exists).toBe(true);
-  });
-
-  it('should use object parameter (physical table name) in syncSchema, not schema.name (FQN)', async () => {
-    // Simulates the real-world scenario: syncRegisteredSchemas passes the
-    // physical table name 'sys_user' while the schema object has name 'sys__user' (FQN).
-    const physicalTableName = 'sys_user';
-    const fqnName = 'sys__user';
-
-    await driver.syncSchema(physicalTableName, {
-      name: fqnName,
-      fields: {
-        email: { type: 'string' },
-        display_name: { type: 'string' },
-      },
-    });
-
-    // The table should be created with the physical name, not the FQN
-    const existsPhysical = await knexInstance.schema.hasTable(physicalTableName);
-    expect(existsPhysical).toBe(true);
-
-    const existsFqn = await knexInstance.schema.hasTable(fqnName);
-    expect(existsFqn).toBe(false);
-
-    // Verify the table has the correct columns
-    const columns = await knexInstance(physicalTableName).columnInfo();
-    expect(columns).toHaveProperty('id');
-    expect(columns).toHaveProperty('email');
-    expect(columns).toHaveProperty('display_name');
-  });
-
-  it('should prefer tableName over name in initObjects for defense-in-depth', async () => {
-    const objects = [
-      {
-        name: 'crm__deal',
-        tableName: 'crm_deal',
-        fields: {
-          amount: { type: 'number' },
-        },
-      },
-    ];
-
-    await driver.initObjects(objects);
-
-    const existsPhysical = await knexInstance.schema.hasTable('crm_deal');
-    expect(existsPhysical).toBe(true);
-
-    const existsFqn = await knexInstance.schema.hasTable('crm__deal');
-    expect(existsFqn).toBe(false);
-  });
-});

package/src/sql-driver.test.ts

@@ -1,108 +0,0 @@
-// 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', { where: { 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');
-  });
-});