@quatrain/backend-sqlite 1.0.6 → 1.0.8

package/dist/SQLiteAdapter.d.ts

@@ -0,0 +1,55 @@
+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>;
+}

package/dist/SQLiteAdapter.js

@@ -0,0 +1,696 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteAdapter = void 0;
+const core_1 = require("@quatrain/core");
+const backend_1 = require("@quatrain/backend");
+const crypto_1 = require("crypto");
+const sqlite3_1 = __importDefault(require("sqlite3"));
+const sqlite_1 = require("sqlite");
+const operatorsMap = {
+    equals: '=',
+    notEquals: '!=',
+    greater: '>',
+    greaterOrEquals: '>=',
+    lower: '<',
+    lowerOrEquals: '<=', // Corrected from '>' in PostgreSQL implementation
+    like: 'LIKE',
+    contains: 'IN',
+    notContains: 'NOT IN',
+    containsAll: 'JSON_EXTRACT', // Use JSON_EXTRACT with custom logic
+    containsAny: 'JSON_EXTRACT', // Use JSON_EXTRACT with custom logic
+    isNull: 'IS NULL',
+    isNotNull: 'IS NOT NULL',
+};
+/**
+ * SQLite Backend Adapter for Quatrain
+ */
+class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
+    constructor(params = {}) {
+        var _a;
+        super(params);
+        this._dbPath = ((_a = params.config) === null || _a === void 0 ? void 0 : _a.database) || ':memory:';
+    }
+    _buildPath(dataObject, uid) {
+        const collection = this.getCollection(dataObject);
+        if (!collection) {
+            throw new backend_1.BackendError(`[SQLA] Can't define record path without a collection name`);
+        }
+        // define document path
+        let path = `${collection}/${uid}`;
+        if (this._params.hierarchy &&
+            this._params.hierarchy[collection] ===
+                backend_1.CollectionHierarchy.SUBCOLLECTION &&
+            dataObject.parentProp &&
+            dataObject.has(dataObject.parentProp) &&
+            dataObject.val(dataObject.parentProp)) {
+            path = `${dataObject.val(dataObject.parentProp).path}/${path}`;
+        }
+        backend_1.Backend.log(`[SQLA] Record path is '${path}'`);
+        return path;
+    }
+    _connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._connection) {
+                // Open SQLite database
+                this._connection = yield (0, sqlite_1.open)({
+                    filename: this._dbPath,
+                    driver: sqlite3_1.default.Database,
+                });
+                // Enable foreign keys support
+                yield this._connection.run('PRAGMA foreign_keys = ON');
+                // Configure SQLite to handle JSON arrays and objects
+                // SQLite doesn't support CREATE FUNCTION syntax, so we'll use built-in JSON functions
+                // Enable JSON1 extension if available
+                try {
+                    yield this._connection.exec('SELECT json_valid(\'[]\')'); // Test if JSON1 is available
+                }
+                catch (err) {
+                    backend_1.Backend.warn('[SQLA] JSON1 extension not available, array operations may be limited');
+                }
+            }
+            return this._connection;
+        });
+    }
+    /**
+     * Process data for compatibility
+     * @param data
+     * @param filterNulls
+     * @returns
+     */
+    _prepareData(data, filterNulls = true) {
+        if (filterNulls) {
+            data = Object.entries(data)
+                .filter(([_, v]) => v !== null && v !== '')
+                .map(([_, v]) => v);
+        }
+        else {
+            data = Object.values(data);
+        }
+        // Handle arrays by converting them to JSON strings for SQLite
+        data.forEach((el, key) => {
+            if (Array.isArray(el)) {
+                data[key] = JSON.stringify(el);
+            }
+        });
+        if (this._params['useNativeForeignKeys'] &&
+            this._params['useNativeForeignKeys'] === true) {
+            data.forEach((el, key) => {
+                if (typeof el === 'object' &&
+                    el !== null &&
+                    Reflect.has(el, 'ref')) {
+                    const resourcePart = el.ref.split('/').pop();
+                    if (resourcePart.indexOf('.') === -1) {
+                        // convert reference for database objects only
+                        data[key] = el.ref.split('/').pop();
+                    }
+                }
+            });
+        }
+        return data;
+    }
+    /**
+     * Ensure the collection table exists in SQLite
+     * @param dataObject DataObject to create table for
+     */
+    _ensureTable(dataObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = this.getCollection(dataObject);
+            if (!collection) {
+                throw new backend_1.BackendError(`[SQLA] Cannot determine collection name`);
+            }
+            const db = yield this._connect();
+            const tableExists = yield db.get(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [collection.toLowerCase()]);
+            if (!tableExists) {
+                // Table doesn't exist, create it
+                let query = `CREATE TABLE IF NOT EXISTS ${collection.toLowerCase()} (
+             id TEXT PRIMARY KEY`;
+                // Add columns based on dataObject properties
+                Object.entries(dataObject.properties).forEach(([prop, propDef]) => {
+                    const propName = prop.toLowerCase();
+                    let columnType = 'TEXT';
+                    // Map property types to SQLite column types
+                    if (propDef.constructor.name === 'NumberProperty') {
+                        columnType = 'REAL';
+                    }
+                    else if (propDef.constructor.name === 'BooleanProperty') {
+                        columnType = 'INTEGER';
+                    }
+                    else if (propDef.constructor.name === 'DateTimeProperty') {
+                        columnType = 'INTEGER'; // Store as timestamp
+                    }
+                    else if (propDef.constructor.name === 'ArrayProperty') {
+                        columnType = 'TEXT'; // Store as JSON string
+                    }
+                    else if (propDef.constructor.name === 'ObjectProperty') {
+                        columnType = 'TEXT'; // Store reference ID
+                    }
+                    query += `,\n${propName} ${columnType}`;
+                });
+                query += `)`;
+                yield db.exec(query);
+                backend_1.Backend.log(`[SQLA] Created table ${collection.toLowerCase()}`);
+            }
+        });
+    }
+    /**
+     * Create record in backend
+     * @param dataObject DataObject instance to persist in backend
+     * @param desiredUid Desired unique ID for record
+     * @returns DataObject
+     */
+    create(dataObject, desiredUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (dataObject.uid) {
+                        throw new backend_1.BackendError(`Data object already has an uid and can't be created`);
+                    }
+                    const uid = desiredUid || (0, crypto_1.randomUUID)();
+                    // Make sure table exists
+                    yield this._ensureTable(dataObject);
+                    // execute middlewares
+                    yield this.executeMiddlewares(dataObject, backend_1.BackendAction.CREATE, {
+                        useDateFormat: true,
+                    });
+                    const data = dataObject.toJSON({
+                        withoutURIData: true,
+                        converters: {
+                            datetime: (v) => (v ? new Date(v).getTime() : v), // Store as timestamp in SQLite
+                        },
+                    });
+                    const db = yield this._connect();
+                    const collection = this.getCollection(dataObject);
+                    let columns = ['id'];
+                    let placeholders = ['?'];
+                    let values = [uid];
+                    Object.entries(data).forEach(([key, value]) => {
+                        columns.push(key.toLowerCase());
+                        placeholders.push('?');
+                        // Convert arrays and objects to JSON strings
+                        if (Array.isArray(value) ||
+                            (typeof value === 'object' && value !== null)) {
+                            values.push(JSON.stringify(value));
+                        }
+                        else {
+                            values.push(value);
+                        }
+                    });
+                    const query = `INSERT INTO ${collection === null || collection === void 0 ? void 0 : collection.toLowerCase()} (${columns.join(', ')})
+                           VALUES (${placeholders.join(', ')})`;
+                    backend_1.Backend.debug(`[SQLA] ${query}`);
+                    backend_1.Backend.debug(`[SQLA] Values ${JSON.stringify(values)}`);
+                    yield db.run(query, values);
+                    dataObject.uri.path = this._buildPath(dataObject, uid);
+                    dataObject.uri.label = data && Reflect.get(data, 'name');
+                    dataObject.isPersisted(true);
+                    backend_1.Backend.info(`[SQLA] Saved object "${data.name}" at path ${dataObject.path}`);
+                    resolve(dataObject);
+                }
+                catch (err) {
+                    console.error(err);
+                    backend_1.Backend.error(err.message);
+                    reject(new backend_1.BackendError(err.message));
+                }
+            }));
+        });
+    }
+    read(dataObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = dataObject.path;
+            const collection = this.getCollection(dataObject);
+            const parts = path.split('/');
+            if (parts.length < 2 || parts.length % 2 !== 0) {
+                throw new backend_1.BackendError(`[SQLA] path parts number should be even, received: '${path}'`);
+            }
+            backend_1.Backend.log(`[SQLA] Getting document ${path}`);
+            if (!collection) {
+                throw new backend_1.BackendError(`[SQLA] Can't find collection matching object to query`);
+            }
+            const db = yield this._connect();
+            const uid = parts[parts.length - 1];
+            // Ensure table exists
+            yield this._ensureTable(dataObject);
+            const result = yield db.get(`SELECT * FROM ${collection.toLowerCase()} WHERE id = ?`, [uid]);
+            if (!result) {
+                throw new core_1.NotFoundError(`[SQLA] No document matches path '${path}'`);
+            }
+            // Process object references
+            for (const prop in dataObject.properties) {
+                const propDef = dataObject.properties[prop];
+                if (propDef.constructor.name === 'ObjectProperty' &&
+                    propDef.instanceOf) {
+                    const propValue = result[prop.toLowerCase()];
+                    if (propValue) {
+                        let refTable = undefined;
+                        if (this._params.mapping && this._params.mapping[propDef.instanceOf]) {
+                            refTable = this._params.mapping[propDef.instanceOf];
+                        }
+                        else if (propDef.instanceOf && propDef.instanceOf.COLLECTION) {
+                            refTable = propDef.instanceOf.COLLECTION;
+                        }
+                        if (refTable) {
+                            // Look up the referenced object for its name
+                            const refObject = yield db.get(`SELECT name FROM ${refTable.toLowerCase()} WHERE id = ?`, [propValue]);
+                            if (refObject) {
+                                result[prop] = {
+                                    ref: `${refTable}/${propValue}`,
+                                    path: `${refTable}/${propValue}`,
+                                    label: refObject.name || '',
+                                };
+                            }
+                        }
+                    }
+                }
+                else if (propDef.constructor.name === 'ArrayProperty') {
+                    // Parse JSON arrays
+                    try {
+                        if (result[prop.toLowerCase()]) {
+                            result[prop] = JSON.parse(result[prop.toLowerCase()]);
+                        }
+                    }
+                    catch (e) {
+                        backend_1.Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`);
+                    }
+                }
+                // Normalize property name case
+                if (prop.toLowerCase() !== prop) {
+                    result[prop] = result[prop.toLowerCase()];
+                }
+            }
+            dataObject.populate(result);
+            return dataObject;
+        });
+    }
+    update(dataObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (dataObject.uid === undefined) {
+                throw new Error('DataObject has no uid');
+            }
+            backend_1.Backend.info(`[SQLA] Updating document ${dataObject.path}`);
+            // execute middlewares
+            yield this.executeMiddlewares(dataObject, backend_1.BackendAction.UPDATE);
+            const data = dataObject.toJSON({
+                withoutURIData: true,
+                ignoreUnchanged: true,
+                converters: {
+                    datetime: (ts) => ts, // Store directly as timestamp in SQLite
+                },
+            });
+            if (Object.keys(data).length === 0) {
+                backend_1.Backend.warn('[SQLA] Nothing to update');
+                return dataObject;
+            }
+            backend_1.Backend.debug(`[SQLA] Data to update ${JSON.stringify(data)}`);
+            const db = yield this._connect();
+            const collection = this.getCollection(dataObject);
+            // Ensure table exists
+            yield this._ensureTable(dataObject);
+            let updates = [];
+            let values = [];
+            Object.entries(data).forEach(([key, value]) => {
+                updates.push(`${key.toLowerCase()} = ?`);
+                // Convert arrays and objects to JSON strings
+                if (Array.isArray(value) ||
+                    (typeof value === 'object' && value !== null)) {
+                    value = JSON.stringify(value);
+                }
+                values.push(value);
+            });
+            if (updates.length === 0) {
+                return dataObject;
+            }
+            values.push(dataObject.uid);
+            const query = `UPDATE ${collection === null || collection === void 0 ? void 0 : collection.toLowerCase()} SET ${updates.join(', ')} WHERE id = ?`;
+            backend_1.Backend.debug(`[SQLA] ${query}`);
+            backend_1.Backend.debug(`[SQLA] Values ${JSON.stringify(values)}`);
+            yield db.run(query, values);
+            return dataObject;
+        });
+    }
+    delete(dataObject, hardDelete = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (dataObject.uid === undefined) {
+                throw new backend_1.BackendError('Dataobject has no uid');
+            }
+            const collection = this.getCollection(dataObject);
+            if (!collection) {
+                throw new backend_1.BackendError(`[SQLA] Cannot determine collection name`);
+            }
+            // execute middlewares
+            yield this.executeMiddlewares(dataObject, backend_1.BackendAction.DELETE, {
+                useDateFormat: true,
+            });
+            const db = yield this._connect();
+            if (!hardDelete) {
+                dataObject.set('status', core_1.statuses.DELETED);
+                yield db.run(`UPDATE ${collection.toLowerCase()} SET status = ? WHERE id = ?`, [core_1.statuses.DELETED, dataObject.uid]);
+            }
+            else {
+                yield db.run(`DELETE FROM ${collection.toLowerCase()} WHERE id = ?`, [
+                    dataObject.uid,
+                ]);
+            }
+            dataObject.uri = new core_1.ObjectUri();
+            return dataObject;
+        });
+    }
+    deleteCollection(collection, batchSize = 500) {
+        return __awaiter(this, void 0, void 0, function* () {
+            backend_1.Backend.log(`Deleting all records from collection '${collection}'`);
+            const db = yield this._connect();
+            // Check if table exists before trying to delete from it
+            const tableExists = yield db.get(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [collection.toLowerCase()]);
+            if (tableExists) {
+                yield db.run(`DELETE FROM ${collection.toLowerCase()}`);
+            }
+        });
+    }
+    /**
+     * Convert array into SQL expression
+     * @param from Array of strings or numbers
+     * @returns string
+     */
+    _array2String(from) {
+        // For SQLite, we'll use the JSON functions to check arrays
+        return `'${JSON.stringify(from)}'`;
+    }
+    /**
+     * Execute a query on a collection
+     * @param dataObject
+     * @param filters
+     * @param pagination
+     * @params parent
+     * @returns
+     */
+    find(dataObject, filters = undefined, pagination = undefined, parent = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                //  use parent path to start fullPath, if available
+                let fullPath = parent ? `${parent.path}/` : '';
+                if (dataObject.path && dataObject.path !== core_1.ObjectUri.DEFAULT) {
+                    fullPath += `${dataObject.path}/`;
+                }
+                const collection = this.getCollection(dataObject);
+                if (!collection) {
+                    throw new backend_1.BackendError(`[SQLA] Can't find collection matching object to query`);
+                }
+                backend_1.Backend.debug(`[SQLA] Preparing query on '${collection}'`);
+                const db = yield this._connect();
+                // Ensure table exists
+                yield this._ensureTable(dataObject);
+                let hasFilters = false;
+                const query = [];
+                const params = [];
+                const joinTables = {};
+                query.push(`SELECT * FROM ${collection.toLowerCase()}`);
+                // Add joins for object references
+                Object.entries(dataObject.properties).forEach(([prop, propDef]) => {
+                    if (propDef.constructor.name === 'ObjectProperty' &&
+                        propDef.instanceOf) {
+                        const propName = prop.toLowerCase();
+                        const joinAlias = `${propName}_table`;
+                        let table = undefined;
+                        if (this._params.mapping && this._params.mapping[propDef.instanceOf]) {
+                            table = this._params.mapping[propDef.instanceOf];
+                        }
+                        else if (propDef.instanceOf && propDef.instanceOf.COLLECTION) {
+                            table = propDef.instanceOf.COLLECTION;
+                        }
+                        if (table) {
+                            joinTables[prop] = { table, alias: joinAlias };
+                            query.push(`LEFT JOIN ${table.toLowerCase()} AS ${joinAlias}
+                      ON ${joinAlias}.id = ${collection.toLowerCase()}.${propName}`);
+                        }
+                        else {
+                            backend_1.Backend.warn(`[SQLA] Skipping join for property ${prop} - no collection found`);
+                        }
+                    }
+                });
+                if (parent) {
+                    query.push(`WHERE ${collection.toLowerCase()}.${dataObject.parentProp} = ?`);
+                    params.push(parent.uid);
+                }
+                if (filters instanceof backend_1.Filters) {
+                    hasFilters = true;
+                    // SQLite doesn't support complex Filters object, but we'll mark it as handled
+                }
+                else if (Array.isArray(filters)) {
+                    // list of filters objects
+                    filters.forEach((filter, i) => {
+                        query.push(parent && i === 0 ? 'AND' : i > 0 ? 'AND' : 'WHERE');
+                        let realProp = filter.prop.toLowerCase();
+                        let realOperator = operatorsMap[filter.operator];
+                        let realValue = filter.value;
+                        if (filter.prop === 'keywords') {
+                            const keywordFilters = [];
+                            const props = dataObject.getProperties(core_1.StringProperty.name);
+                            Object.keys(props).forEach((rp) => {
+                                keywordFilters.push(`${collection.toLowerCase()}.${rp.toLowerCase()} LIKE ?`);
+                                params.push(`%${filter.value}%`);
+                            });
+                            query.push(`(${keywordFilters.join(' OR ')})`);
+                        }
+                        else if (filter.prop !== backend_1.AbstractBackendAdapter.PKEY_IDENTIFIER &&
+                            !dataObject.has(filter.prop)) {
+                            throw new backend_1.BackendError(`[SQLA] No such property '${filter.prop}' on object'`);
+                        }
+                        else if (filter.prop === backend_1.AbstractBackendAdapter.PKEY_IDENTIFIER) {
+                            realProp = 'id';
+                        }
+                        else {
+                            const property = dataObject.get(filter.prop);
+                            realProp = filter.prop.toLowerCase();
+                            if (property.constructor.name === 'ArrayProperty' &&
+                                Array.isArray(realValue)) {
+                                // Use EXISTS with json_each for array containment in SQLite
+                                const placeholders = realValue.map(() => 'json_each.value = ?').join(' OR ');
+                                query.push(`EXISTS (SELECT 1 FROM json_each(${collection.toLowerCase()}.${realProp}) WHERE ${placeholders})`);
+                                params.push(...realValue);
+                                // Skip further processing for this filter
+                                backend_1.Backend.debug(`[SQLA] Array filter added: ${realProp} EXISTS ${String(realValue)}`);
+                            }
+                            else if (property.constructor.name === 'ObjectProperty') {
+                                if (filter.value instanceof core_1.ObjectUri) {
+                                    realValue = filter.value.uid;
+                                }
+                                else if (filter.value &&
+                                    typeof filter.value === 'object' &&
+                                    filter.value.ref) {
+                                    realValue = filter.value.ref.split('/')[1];
+                                }
+                                else if (typeof filter.value === 'string') {
+                                    const collectionName = this._params.mapping &&
+                                        this._params.mapping[dataObject.properties[filter.prop].instanceOf]
+                                        ? this._params.mapping[dataObject.properties[filter.prop].instanceOf]
+                                        : dataObject.properties[filter.prop].instanceOf
+                                            .COLLECTION;
+                                    realValue = filter.value.replace(`${collectionName}/`, '');
+                                }
+                                else if (filter.value &&
+                                    typeof filter.value === 'object' &&
+                                    filter.value.uid) {
+                                    // Handle DataObject instances
+                                    realValue = filter.value.uid;
+                                }
+                                else {
+                                    realValue =
+                                        (filter.value &&
+                                            filter.value.uri &&
+                                            filter.value.uri.path &&
+                                            filter.value.uri.path.split('/')[1]) ||
+                                            filter.value;
+                                }
+                            }
+                            // Only add the filter query if it's not an ArrayProperty (which was already handled above)
+                            if (!(property.constructor.name === 'ArrayProperty' && Array.isArray(realValue))) {
+                                if (realOperator === operatorsMap['containsAny']) {
+                                    // Use EXISTS with json_each for array containment in SQLite
+                                    query.push(`EXISTS (SELECT 1 FROM json_each(${collection.toLowerCase()}.${realProp}) WHERE json_each.value = ?)`);
+                                    params.push(realValue);
+                                }
+                                else if (realOperator === operatorsMap['equals'] &&
+                                    realValue === 'null') {
+                                    query.push(`${collection.toLowerCase()}.${realProp} IS NULL`);
+                                }
+                                else if (realOperator === operatorsMap['contains'] ||
+                                    realOperator === operatorsMap['notContains']) {
+                                    if (Array.isArray(realValue)) {
+                                        const placeholders = realValue.map(() => '?').join(', ');
+                                        query.push(`${collection.toLowerCase()}.${realProp} ${realOperator} (${placeholders})`);
+                                        params.push(...realValue);
+                                    }
+                                    else {
+                                        query.push(`${collection.toLowerCase()}.${realProp} ${realOperator} (?)`);
+                                        params.push(realValue);
+                                    }
+                                }
+                                else {
+                                    // Handle ObjectProperty specially for JSON-stored references
+                                    if (property && property.constructor.name === 'ObjectProperty') {
+                                        if (realOperator === operatorsMap.equals) {
+                                            // For ObjectProperty, check if the JSON contains the reference
+                                            query.push(`json_extract(${collection.toLowerCase()}.${realProp}, '$.ref') LIKE ?`);
+                                            params.push(`%${realValue}`);
+                                        }
+                                        else {
+                                            query.push(`${collection.toLowerCase()}.${realProp} ${realOperator} ?`);
+                                            params.push(realValue);
+                                        }
+                                    }
+                                    else if (realOperator === operatorsMap.like) {
+                                        query.push(`${collection.toLowerCase()}.${realProp} ${realOperator} ?`);
+                                        params.push(`%${realValue}%`);
+                                    }
+                                    else if (realOperator === operatorsMap.isNull ||
+                                        realOperator === operatorsMap.isNotNull) {
+                                        query.push(`${collection.toLowerCase()}.${realProp} ${realOperator}`);
+                                    }
+                                    else {
+                                        query.push(`${collection.toLowerCase()}.${realProp} ${realOperator} ?`);
+                                        params.push(realValue);
+                                    }
+                                }
+                                backend_1.Backend.debug(`[SQLA] Filter added: ${realProp} ${realOperator} ${String(realValue)}`);
+                            }
+                        }
+                    });
+                }
+                // Count query - without pagination
+                const countQuery = query.join(' ').replace('*', 'COUNT(*) as total');
+                backend_1.Backend.debug(`[SQLA] Count SQL ${countQuery}`);
+                const countResult = yield db.get(countQuery, params);
+                const totalCount = countResult ? countResult.total : 0;
+                backend_1.Backend.debug(`[SQLA] Counting records ${totalCount}`);
+                // Add sorting and pagination
+                let sortField = [];
+                if (pagination && pagination.sortings) {
+                    pagination.sortings.forEach((sorting, i) => {
+                        query.push(i === 0 ? `ORDER BY` : ',');
+                        query.push(`${collection.toLowerCase()}.${sorting.prop.toLowerCase()} ${sorting.order}`);
+                        if (sorting.prop !== undefined) {
+                            sortField.push(`${sorting.prop} ${sorting.order.toUpperCase()}`);
+                        }
+                    });
+                    if ((pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) !== -1) {
+                        query.push(`LIMIT ?`);
+                        params.push(pagination.limits.batch);
+                    }
+                    if (pagination === null || pagination === void 0 ? void 0 : pagination.limits.offset) {
+                        query.push(`OFFSET ?`);
+                        params.push(pagination.limits.offset);
+                    }
+                }
+                const finalQuery = query.join(' ');
+                backend_1.Backend.debug(`[SQLA] Full SQL ${finalQuery}`);
+                backend_1.Backend.debug(`[SQLA] Params ${JSON.stringify(params)}`);
+                const results = yield db.all(finalQuery, params);
+                const meta = {
+                    count: totalCount,
+                    offset: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.offset) || 0,
+                    batch: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) || 20,
+                    sortField: sortField.join(', '),
+                    executionTime: backend_1.Backend.timestamp(),
+                    debug: { sql: finalQuery, params },
+                };
+                const items = [];
+                for (let doc of results || []) {
+                    // Process document before populating
+                    Object.entries(dataObject.properties).forEach(([prop, propDef]) => {
+                        const lcProp = prop.toLowerCase();
+                        // Handle ObjectProperty references
+                        if (propDef.constructor.name === 'ObjectProperty' &&
+                            propDef.instanceOf) {
+                            const refValue = doc[lcProp];
+                            if (refValue) {
+                                const info = joinTables[prop];
+                                if (info) {
+                                    const label = doc[`${lcProp}_table_name`] || '';
+                                    doc[prop] = {
+                                        ref: `${info.table}/${refValue}`,
+                                        path: `${info.table}/${refValue}`,
+                                        label,
+                                    };
+                                }
+                                else {
+                                    // Fallback when no join table info is available
+                                    // Try to determine table name from propDef
+                                    let tableName = undefined;
+                                    if (this._params.mapping && this._params.mapping[propDef.instanceOf]) {
+                                        tableName = this._params.mapping[propDef.instanceOf];
+                                    }
+                                    else if (propDef.instanceOf && propDef.instanceOf.COLLECTION) {
+                                        tableName = propDef.instanceOf.COLLECTION;
+                                    }
+                                    if (tableName) {
+                                        doc[prop] = {
+                                            ref: `${tableName}/${refValue}`,
+                                            path: `${tableName}/${refValue}`,
+                                            label: '',
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                        // Handle array properties
+                        else if (propDef.constructor.name === 'ArrayProperty') {
+                            try {
+                                if (doc[lcProp]) {
+                                    doc[prop] = JSON.parse(doc[lcProp]);
+                                }
+                            }
+                            catch (e) {
+                                backend_1.Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`);
+                            }
+                        }
+                        // Ensure property is available with original case
+                        if (prop !== lcProp) {
+                            doc[prop] = doc[lcProp];
+                        }
+                    });
+                    const newDataObject = yield dataObject.clone(Object.assign({}, doc));
+                    let newDataObjectUri = ``;
+                    if (newDataObject.has('parent')) {
+                        if (!(newDataObject.val('parent') &&
+                            newDataObject.val('parent').path)) {
+                            throw new backend_1.BackendError(`DataObject has parent but parent is not persisted`);
+                        }
+                        newDataObjectUri = `${newDataObject.get('parent')._value._path}/`;
+                    }
+                    newDataObjectUri += `${this.getCollection(dataObject)}/${doc.id}`;
+                    newDataObject.uri = new core_1.ObjectUri(newDataObjectUri, newDataObject.val('name'));
+                    items.push(newDataObject);
+                }
+                return { items, meta };
+            }
+            catch (err) {
+                console.error(err);
+                backend_1.Backend.error(`[SQLA] Query failed: ${err.message}`);
+                throw new backend_1.BackendError(`Query failed for '${dataObject.class.name}': ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Close the SQLite connection
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._connection) {
+                yield this._connection.close();
+                this._connection = undefined;
+            }
+        });
+    }
+}
+exports.SQLiteAdapter = SQLiteAdapter;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteAdapter = void 0;
+const SQLiteAdapter_1 = require("./SQLiteAdapter");
+Object.defineProperty(exports, "SQLiteAdapter", { enumerable: true, get: function () { return SQLiteAdapter_1.SQLiteAdapter; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/backend-sqlite",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "license": "AGPL-3.0-only",
   "description": "Backend adapter for SQLite",
   "main": "dist/index.js",
@@ -14,8 +14,8 @@
   ],
   "author": "Quatrain Développement SAS <developers@quatrain.com>",
   "dependencies": {
-    "@quatrain/backend": "^1.1.28",
-    "@quatrain/core": "^1.1.43",
+    "@quatrain/backend": "^1.1.30",
+    "@quatrain/core": "^1.1.45",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7"
   },