@quatrain/backend-sqlite 1.0.2 → 1.0.3

package/src/__test__/Search.test.ts

@@ -0,0 +1,325 @@
+import { User } from '@quatrain/backend'
+import { Filter, OperatorKeys } from '@quatrain/backend'
+import { setup, createUser, createEntity, Entity } from './common'
+
+describe('SQLite Search Operations', () => {
+   let adapter: any
+   let user: User
+   let entity: Entity
+
+   beforeAll(async () => {
+      adapter = setup()
+
+      // Create test entity
+      entity = await createEntity()
+      await adapter.create(entity.dataObject, undefined)
+
+      // Create multiple test users
+      const users = []
+      for (let i = 0; i < 10; i++) {
+         const testUser = await User.factory()
+         testUser._.firstname = `TestUser${i}`
+         testUser._.lastname = i % 2 === 0 ? 'Even' : 'Odd'
+         testUser._.email = `testuser${i}@example.com`
+         testUser._.password = 'password'
+         
+         // Some users belong to the entity
+         if (i < 5) {
+            testUser._.entity = entity
+         }
+         
+         await adapter.create(testUser.dataObject, undefined)
+         users.push(testUser)
+      }
+
+      user = users[0]
+   })
+
+   afterAll(async () => {
+      await adapter.deleteCollection('user')
+      await adapter.deleteCollection('entities')
+      await adapter.close()
+   })
+
+   describe('Basic Search Operations', () => {
+      test('find all users without filters', async () => {
+         const searchUser = await User.factory()
+         const result = await adapter.find(searchUser.dataObject)
+         
+         expect(result.items.length).toBe(10)
+         expect(result.meta.count).toBe(10)
+         expect(result.meta.batch).toBe(20) // Default batch size
+         expect(result.meta.offset).toBe(0)
+      })
+
+      test('find users with firstname filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'TestUser5', OperatorKeys.equals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(1)
+         expect(result.items[0].val('firstname')).toBe('TestUser5')
+      })
+
+      test('find users with lastname filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('lastname', 'Even', OperatorKeys.equals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(5)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('lastname')).toBe('Even')
+         })
+      })
+
+      test('find users with multiple filters', async () => {
+         const searchUser = await User.factory()
+         const filters = [
+            new Filter('lastname', 'Even', OperatorKeys.equals),
+            new Filter('firstname', 'TestUser0', OperatorKeys.equals)
+         ]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(1)
+         expect(result.items[0].val('firstname')).toBe('TestUser0')
+         expect(result.items[0].val('lastname')).toBe('Even')
+      })
+   })
+
+   describe('Comparison Operators', () => {
+      test('greater than filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'TestUser5', OperatorKeys.greater)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBeGreaterThan(0)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('firstname') > 'TestUser5').toBe(true)
+         })
+      })
+
+      test('less than filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'TestUser5', OperatorKeys.lower)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBeGreaterThan(0)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('firstname') < 'TestUser5').toBe(true)
+         })
+      })
+
+      test('not equals filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('lastname', 'Even', OperatorKeys.notEquals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(5)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('lastname')).not.toBe('Even')
+         })
+      })
+
+      test('greater than or equals filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'TestUser5', OperatorKeys.greaterOrEquals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBeGreaterThan(0)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('firstname') >= 'TestUser5').toBe(true)
+         })
+      })
+
+      test('less than or equals filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'TestUser5', OperatorKeys.lowerOrEquals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBeGreaterThan(0)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('firstname') <= 'TestUser5').toBe(true)
+         })
+      })
+   })
+
+   describe('Text Search Operations', () => {
+      test('keywords search across multiple fields', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('keywords', 'TestUser', OperatorKeys.like)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(10) // All users have "TestUser" in firstname
+      })
+
+      test('keywords search with specific term', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('keywords', 'testuser3@example.com', OperatorKeys.like)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBeGreaterThan(0)
+      })
+
+      test('like filter on specific field', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('email', '@example.com', OperatorKeys.like)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(10) // All test users have @example.com
+      })
+   })
+
+   describe('Pagination and Sorting', () => {
+      test('pagination with limit', async () => {
+         const searchUser = await User.factory()
+         const pagination = {
+            limits: { batch: 3, offset: 0 },
+            sortings: [{ prop: 'firstname', order: 'asc' as const }]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, undefined, pagination)
+         expect(result.items.length).toBe(3)
+         expect(result.meta.batch).toBe(3)
+         expect(result.meta.offset).toBe(0)
+         expect(result.meta.count).toBe(10) // Total count should still be 10
+      })
+
+      test('pagination with offset', async () => {
+         const searchUser = await User.factory()
+         const pagination = {
+            limits: { batch: 3, offset: 3 },
+            sortings: [{ prop: 'firstname', order: 'asc' as const }]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, undefined, pagination)
+         expect(result.items.length).toBe(3)
+         expect(result.meta.offset).toBe(3)
+      })
+
+      test('sorting ascending', async () => {
+         const searchUser = await User.factory()
+         const pagination = {
+            limits: { batch: 5, offset: 0 },
+            sortings: [{ prop: 'firstname', order: 'asc' as const }]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, undefined, pagination)
+         
+         for (let i = 1; i < result.items.length; i++) {
+            const prev = result.items[i-1].val('firstname')
+            const curr = result.items[i].val('firstname')
+            expect(prev <= curr).toBe(true)
+         }
+      })
+
+      test('sorting descending', async () => {
+         const searchUser = await User.factory()
+         const pagination = {
+            limits: { batch: 5, offset: 0 },
+            sortings: [{ prop: 'firstname', order: 'desc' as const }]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, undefined, pagination)
+         
+         for (let i = 1; i < result.items.length; i++) {
+            const prev = result.items[i-1].val('firstname')
+            const curr = result.items[i].val('firstname')
+            expect(prev >= curr).toBe(true)
+         }
+      })
+
+      test('multiple sorting criteria', async () => {
+         const searchUser = await User.factory()
+         const pagination = {
+            limits: { batch: 10, offset: 0 },
+            sortings: [
+               { prop: 'lastname', order: 'asc' as const },
+               { prop: 'firstname', order: 'desc' as const }
+            ]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, undefined, pagination)
+         expect(result.items.length).toBe(10)
+         expect(result.meta.sortField).toContain('lastname ASC')
+         expect(result.meta.sortField).toContain('firstname DESC')
+      })
+   })
+
+   describe('Object Reference Filters', () => {
+      test('filter by entity reference', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('entity', entity, OperatorKeys.equals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(5) // 5 users have this entity
+         
+         result.items.forEach((item: any) => {
+            const entityValue = item.val('entity')
+            expect(entityValue).toBeDefined()
+         })
+      })
+
+      test('filter by null entity', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('entity', 'null', OperatorKeys.equals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(5) // 5 users don't have entity
+      })
+   })
+
+   describe('Complex Queries', () => {
+      test('combined filters with pagination and sorting', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('lastname', 'Even', OperatorKeys.equals)]
+         const pagination = {
+            limits: { batch: 2, offset: 1 },
+            sortings: [{ prop: 'firstname', order: 'asc' as const }]
+         }
+         
+         const result = await adapter.find(searchUser.dataObject, filters, pagination)
+         expect(result.items.length).toBe(2)
+         expect(result.meta.count).toBe(5) // Total matching records
+         expect(result.meta.offset).toBe(1)
+         
+         result.items.forEach((item: any) => {
+            expect(item.val('lastname')).toBe('Even')
+         })
+      })
+
+      test('no results query', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('firstname', 'NonExistentUser', OperatorKeys.equals)]
+         
+         const result = await adapter.find(searchUser.dataObject, filters)
+         expect(result.items.length).toBe(0)
+         expect(result.meta.count).toBe(0)
+      })
+   })
+
+   describe('Error Cases', () => {
+      test('invalid property name in filter', async () => {
+         const searchUser = await User.factory()
+         const filters = [new Filter('invalidProperty', 'value', OperatorKeys.equals)]
+         
+         await expect(adapter.find(searchUser.dataObject, filters)).rejects.toThrow()
+      })
+
+      test('invalid collection for search', async () => {
+         const searchUser = await User.factory()
+         // Force collection to be undefined
+         Object.defineProperty(searchUser.dataObject.uri, 'collection', {
+            value: undefined,
+            writable: true
+         })
+         
+         await expect(adapter.find(searchUser.dataObject)).rejects.toThrow()
+      })
+   })
+})

package/src/__test__/common.ts

@@ -0,0 +1,61 @@
+import { User, PersistedBaseObject } from '@quatrain/backend'
+import { Entity as CoreEntity } from '@quatrain/core'
+import { SQLiteAdapter } from '../SQLiteAdapter'
+
+// Create a simple Entity class that extends PersistedBaseObject for testing
+class Entity extends PersistedBaseObject {
+   static COLLECTION = 'entities'
+   static PROPS_DEFINITION = CoreEntity.PROPS_DEFINITION
+
+   static async factory(src: any = undefined): Promise<Entity> {
+      return super.factory(src, Entity)
+   }
+}
+
+export const setup = (dbPath: string = ':memory:') => {
+   return new SQLiteAdapter({
+      config: {
+         database: dbPath
+      },
+   })
+}
+
+export const createUser = async () => {
+   const user = await User.factory()
+   user._.firstname = 'John'
+   user._.lastname = 'Doe'
+   user._.email = 'john@doe.com'
+   user._.password = 'password123'
+
+   return user
+}
+
+export const createEntity = async () => {
+   const entity = await Entity.factory()
+   entity._.name = 'ACME Inc.'
+
+   return entity
+}
+
+export const createUsers = async (
+   userModel: User,
+   qty: number = 5,
+   forcedValues: any = {}
+): Promise<User[]> => {
+   // Simple data generator since utils.DataGenerator is not available
+   const users: User[] = []
+   for (let i = 0; i < qty; i++) {
+      const user = await User.factory()
+      user._.firstname = forcedValues.firstname || `User${i}`
+      user._.lastname = forcedValues.lastname || 'Test'
+      user._.email = forcedValues.email || `user${i}@test.com`
+      user._.password = forcedValues.password || 'password'
+      if (forcedValues.entity) {
+         user._.entity = forcedValues.entity
+      }
+      users.push(user)
+   }
+   return users
+}
+
+export { Entity }

package/src/index.ts

@@ -0,0 +1,3 @@
+import { SQLiteAdapter } from './SQLiteAdapter'
+
+export { SQLiteAdapter }

package/lib/SQLiteAdapter.d.ts

@@ -1,55 +0,0 @@
-import { DataObjectClass, AbstractBackendAdapter, BackendParameters, QueryResultType, Filters, Filter, SortAndLimit } from '@quatrain/backend';
-import sqlite3 from 'sqlite3';
-import { Database } from 'sqlite';
-/**
- * SQLite Backend Adapter for Quatrain
- */
-export declare class SQLiteAdapter extends AbstractBackendAdapter {
-    protected _connection: undefined | Database<sqlite3.Database>;
-    protected _dbPath: string;
-    constructor(params?: BackendParameters);
-    protected _buildPath(dataObject: DataObjectClass<any>, uid?: string): string;
-    protected _connect(): Promise<Database<sqlite3.Database>>;
-    /**
-     * Process data for compatibility
-     * @param data
-     * @param filterNulls
-     * @returns
-     */
-    protected _prepareData(data: any, filterNulls?: boolean): any;
-    /**
-     * Ensure the collection table exists in SQLite
-     * @param dataObject DataObject to create table for
-     */
-    private _ensureTable;
-    /**
-     * Create record in backend
-     * @param dataObject DataObject instance to persist in backend
-     * @param desiredUid Desired unique ID for record
-     * @returns DataObject
-     */
-    create(dataObject: DataObjectClass<any>, desiredUid: string | undefined): Promise<DataObjectClass<any>>;
-    read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    delete(dataObject: DataObjectClass<any>, hardDelete?: boolean): Promise<DataObjectClass<any>>;
-    deleteCollection(collection: string, batchSize?: number): Promise<void>;
-    /**
-     * Convert array into SQL expression
-     * @param from Array of strings or numbers
-     * @returns string
-     */
-    protected _array2String(from: (string | number)[]): string;
-    /**
-     * Execute a query on a collection
-     * @param dataObject
-     * @param filters
-     * @param pagination
-     * @params parent
-     * @returns
-     */
-    find(dataObject: DataObjectClass<any>, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined, parent?: DataObjectClass<any> | undefined): Promise<QueryResultType<DataObjectClass<any>>>;
-    /**
-     * Close the SQLite connection
-     */
-    close(): Promise<void>;
-}