@quatrain/backend-sqlite 1.0.16 → 1.1.2

package/dist/SQLiteAdapter.d.ts

@@ -9,6 +9,11 @@ export declare class SQLiteAdapter extends AbstractBackendAdapter {
     protected _dbPath: string;
     constructor(params?: BackendParameters);
     protected _buildPath(dataObject: DataObjectClass<any>, uid?: string): string;
+    /**
+     * Executes a raw query on the backend.
+     * Only supported by SQL adapters.
+     */
+    rawQuery(sql: string, params?: any[]): Promise<any>;
     protected _connect(): Promise<Database<sqlite3.Database>>;
     /**
      * Process data for compatibility
@@ -52,4 +57,18 @@ export declare class SQLiteAdapter extends AbstractBackendAdapter {
      * Close the SQLite connection
      */
     close(): Promise<void>;
+    /**
+     * Generates the SQL up and down statements to create a collection table.
+     */
+    generateCreateSql(collection: string, properties: any[]): {
+        upSql: string;
+        downSql: string;
+    };
+    /**
+     * Generates the SQL up and down statements to apply a schema delta to a collection.
+     */
+    generateDeltaSql(collection: string, delta: any): {
+        upSql: string[];
+        downSql: string[];
+    };
 }

package/dist/SQLiteAdapter.js

@@ -57,9 +57,19 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
             dataObject.val(dataObject.parentProp)) {
             path = `${dataObject.val(dataObject.parentProp).path}/${path}`;
         }
-        backend_1.Backend.log(`[SQLA] Record path is '${path}'`);
+        backend_1.Backend.info(`[SQLA] Record path is '${path}'`);
         return path;
     }
+    /**
+     * Executes a raw query on the backend.
+     * Only supported by SQL adapters.
+     */
+    rawQuery(sql_1) {
+        return __awaiter(this, arguments, void 0, function* (sql, params = []) {
+            const connection = yield this._connect();
+            return yield connection.all(sql, params);
+        });
+    }
     _connect() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._connection) {
@@ -138,7 +148,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
              id TEXT PRIMARY KEY`;
                 // Add columns based on dataObject properties
                 Object.entries(dataObject.properties).forEach(([prop, propDef]) => {
-                    const propName = prop.toLowerCase();
+                    const propName = prop;
                     let columnType = 'TEXT';
                     // Map property types to SQLite column types
                     if (propDef.constructor.name === 'NumberProperty') {
@@ -160,7 +170,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 });
                 query += `)`;
                 yield db.exec(query);
-                backend_1.Backend.log(`[SQLA] Created table ${collection.toLowerCase()}`);
+                backend_1.Backend.info(`[SQLA] Created table ${collection.toLowerCase()}`);
             }
         });
     }
@@ -196,7 +206,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                     let placeholders = ['?'];
                     let values = [uid];
                     Object.entries(data).forEach(([key, value]) => {
-                        columns.push(key.toLowerCase());
+                        columns.push(`"${key}"`);
                         placeholders.push('?');
                         // Convert arrays and objects to JSON strings
                         if (Array.isArray(value) ||
@@ -234,7 +244,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
             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}`);
+            backend_1.Backend.info(`[SQLA] Getting document ${path}`);
             if (!collection) {
                 throw new backend_1.BackendError(`[SQLA] Can't find collection matching object to query`);
             }
@@ -251,7 +261,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 const propDef = dataObject.properties[prop];
                 if (propDef.constructor.name === 'ObjectProperty' &&
                     propDef.instanceOf) {
-                    const propValue = result[prop.toLowerCase()];
+                    const propValue = result[prop];
                     if (propValue) {
                         let refTable = undefined;
                         if (this._params.mapping && this._params.mapping[propDef.instanceOf]) {
@@ -273,21 +283,17 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                         }
                     }
                 }
-                else if (propDef.constructor.name === 'ArrayProperty') {
-                    // Parse JSON arrays
+                else if (propDef.constructor.name === 'ArrayProperty' || propDef.constructor.name === 'MapProperty') {
+                    // Parse JSON arrays and objects
                     try {
-                        if (result[prop.toLowerCase()]) {
-                            result[prop] = JSON.parse(result[prop.toLowerCase()]);
+                        if (result[prop]) {
+                            result[prop] = JSON.parse(result[prop]);
                         }
                     }
                     catch (e) {
-                        backend_1.Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`);
+                        backend_1.Backend.warn(`[SQLA] Failed to parse JSON for ${prop}: ${e}`);
                     }
                 }
-                // Normalize property name case
-                if (prop.toLowerCase() !== prop) {
-                    result[prop] = result[prop.toLowerCase()];
-                }
             }
             dataObject.populate(result);
             return dataObject;
@@ -312,7 +318,6 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 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
@@ -320,7 +325,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
             let updates = [];
             let values = [];
             Object.entries(data).forEach(([key, value]) => {
-                updates.push(`${key.toLowerCase()} = ?`);
+                updates.push(`"${key}" = ?`);
                 // Convert arrays and objects to JSON strings
                 if (Array.isArray(value) ||
                     (typeof value === 'object' && value !== null)) {
@@ -353,7 +358,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 useDateFormat: true,
             });
             const db = yield this._connect();
-            if (!hardDelete) {
+            if (this._params.softDelete !== false && !hardDelete) {
                 dataObject.set('status', core_1.statuses.DELETED);
                 yield db.run(`UPDATE ${collection.toLowerCase()} SET status = ? WHERE id = ?`, [core_1.statuses.DELETED, dataObject.uid]);
             }
@@ -419,7 +424,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 Object.entries(dataObject.properties).forEach(([prop, propDef]) => {
                     if (propDef.constructor.name === 'ObjectProperty' &&
                         propDef.instanceOf) {
-                        const propName = prop.toLowerCase();
+                        const propName = prop;
                         const joinAlias = `${propName}_table`;
                         let table = undefined;
                         if (this._params.mapping && this._params.mapping[propDef.instanceOf]) {
@@ -450,14 +455,14 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                     // list of filters objects
                     filters.forEach((filter, i) => {
                         query.push(parent && i === 0 ? 'AND' : i > 0 ? 'AND' : 'WHERE');
-                        let realProp = filter.prop.toLowerCase();
+                        let realProp = filter.prop;
                         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 ?`);
+                                keywordFilters.push(`${collection.toLowerCase()}.${rp} LIKE ?`);
                                 params.push(`%${filter.value}%`);
                             });
                             query.push(`(${keywordFilters.join(' OR ')})`);
@@ -471,7 +476,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                         }
                         else {
                             const property = dataObject.get(filter.prop);
-                            realProp = filter.prop.toLowerCase();
+                            realProp = filter.prop;
                             if (property.constructor.name === 'ArrayProperty' &&
                                 Array.isArray(realValue)) {
                                 // Use EXISTS with json_each for array containment in SQLite
@@ -578,7 +583,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 if (pagination && pagination.sortings) {
                     pagination.sortings.forEach((sorting, i) => {
                         query.push(i === 0 ? `ORDER BY` : ',');
-                        query.push(`${collection.toLowerCase()}.${sorting.prop.toLowerCase()} ${sorting.order}`);
+                        query.push(`${collection.toLowerCase()}.${sorting.prop} ${sorting.order}`);
                         if (sorting.prop !== undefined) {
                             sortField.push(`${sorting.prop} ${sorting.order.toUpperCase()}`);
                         }
@@ -608,15 +613,14 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                 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];
+                            const refValue = doc[prop];
                             if (refValue) {
                                 const info = joinTables[prop];
                                 if (info) {
-                                    const label = doc[`${lcProp}_table_name`] || '';
+                                    const label = doc[`${prop}_table_name`] || '';
                                     doc[prop] = {
                                         ref: `${info.table}/${refValue}`,
                                         path: `${info.table}/${refValue}`,
@@ -643,22 +647,22 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                                 }
                             }
                         }
-                        // Handle array properties
-                        else if (propDef.constructor.name === 'ArrayProperty') {
+                        // Handle array and map properties
+                        else if (propDef.constructor.name === 'ArrayProperty' || propDef.constructor.name === 'MapProperty') {
                             try {
-                                if (doc[lcProp]) {
-                                    doc[prop] = JSON.parse(doc[lcProp]);
+                                if (doc[prop] && typeof doc[prop] === 'string') {
+                                    doc[prop] = JSON.parse(doc[prop]);
                                 }
                             }
                             catch (e) {
-                                backend_1.Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`);
+                                backend_1.Backend.warn(`[SQLA] Failed to parse JSON for ${prop}: ${e}`);
                             }
                         }
-                        // Ensure property is available with original case
-                        if (prop !== lcProp) {
-                            doc[prop] = doc[lcProp];
-                        }
                     });
+                    // Map SQLite 'id' column back to Quatrain 'uid' property
+                    if (doc.id && !doc.uid) {
+                        doc.uid = doc.id;
+                    }
                     const newDataObject = yield dataObject.clone(Object.assign({}, doc));
                     let newDataObjectUri = ``;
                     if (newDataObject.has('parent')) {
@@ -692,5 +696,77 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
             }
         });
     }
+    /**
+     * Generates the SQL up and down statements to create a collection table.
+     */
+    generateCreateSql(collection, properties) {
+        let query = `CREATE TABLE IF NOT EXISTS "${collection.toLowerCase()}" (\n    id TEXT PRIMARY KEY`;
+        properties.forEach((propDef) => {
+            const propName = propDef.name;
+            let columnType = 'TEXT';
+            const type = propDef.type || propDef.constructor.name;
+            if (type === 'NumberProperty') {
+                columnType = 'REAL';
+            }
+            else if (type === 'BooleanProperty') {
+                columnType = 'INTEGER';
+            }
+            else if (type === 'DateTimeProperty') {
+                columnType = 'INTEGER';
+            }
+            else if (type === 'ArrayProperty') {
+                columnType = 'TEXT';
+            }
+            else if (type === 'ObjectProperty') {
+                columnType = 'TEXT';
+            }
+            query += `,\n    "${propName}" ${columnType}`;
+        });
+        query += `\n)`;
+        return {
+            upSql: `await adapter.rawQuery(\`${query}\`)`,
+            downSql: `await adapter.rawQuery(\`DROP TABLE IF EXISTS "${collection.toLowerCase()}"\`)`,
+        };
+    }
+    /**
+     * Generates the SQL up and down statements to apply a schema delta to a collection.
+     */
+    generateDeltaSql(collection, delta) {
+        const upSql = [];
+        const downSql = [];
+        // Added columns
+        delta.added.forEach((propDef) => {
+            const propName = propDef.name;
+            let columnType = 'TEXT';
+            const type = propDef.type || propDef.constructor.name;
+            if (type === 'NumberProperty') {
+                columnType = 'REAL';
+            }
+            else if (type === 'BooleanProperty') {
+                columnType = 'INTEGER';
+            }
+            else if (type === 'DateTimeProperty') {
+                columnType = 'INTEGER';
+            }
+            upSql.push(`await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" ADD COLUMN "${propName}" ${columnType}\`)`);
+            // SQLite < 3.35 doesn't support DROP COLUMN, so we add a comment but keep the syntax
+            downSql.push(`// NOTE: DROP COLUMN requires SQLite >= 3.35\n   // await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" DROP COLUMN "${propName}"\`)`);
+        });
+        // Removed columns
+        delta.removed.forEach((propDef) => {
+            const propName = propDef.name;
+            let columnType = 'TEXT';
+            const type = propDef.type || propDef.constructor.name;
+            if (type === 'NumberProperty')
+                columnType = 'REAL';
+            else if (type === 'BooleanProperty')
+                columnType = 'INTEGER';
+            else if (type === 'DateTimeProperty')
+                columnType = 'INTEGER';
+            upSql.push(`// NOTE: DROP COLUMN requires SQLite >= 3.35\n   // await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" DROP COLUMN "${propName}"\`)`);
+            downSql.push(`await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" ADD COLUMN "${propName}" ${columnType}\`)`);
+        });
+        return { upSql, downSql };
+    }
 }
 exports.SQLiteAdapter = SQLiteAdapter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/backend-sqlite",
-  "version": "1.0.16",
+  "version": "1.1.2",
   "license": "AGPL-3.0-only",
   "description": "Backend adapter for SQLite",
   "main": "dist/index.js",
@@ -20,8 +20,8 @@
   },
   "author": "Quatrain Développement SAS <developers@quatrain.com>",
   "dependencies": {
-    "@quatrain/backend": "^1.1.37",
-    "@quatrain/core": "^1.1.51",
+    "@quatrain/backend": "^1.2.1",
+    "@quatrain/core": "^1.2.2",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7"
   },
@@ -43,5 +43,8 @@
     "build": "tsc",
     "wbuild": "tsc --watch",
     "bump-to": "yarn version"
+  },
+  "typedoc": {
+    "entryPoint": "src/index.ts"
   }
 }

package/src/SQLiteAdapter.ts

@@ -3,7 +3,6 @@ import {
    NotFoundError,
    statuses,
    StringProperty,
-   ObjectProperty,
 } from '@quatrain/core'
 import {
    DataObjectClass,
@@ -23,7 +22,6 @@ import {
 import { randomUUID } from 'crypto'
 import sqlite3, { Statement } from 'sqlite3'
 import { open, Database } from 'sqlite'
-import { AbstractPropertyType } from '@quatrain/core/dist/properties/types/AbstractPropertyType'
 
 const operatorsMap: { [x: string]: string } = {
    equals: '=',
@@ -74,11 +72,20 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          path = `${dataObject.val(dataObject.parentProp).path}/${path}`
       }
 
-      Backend.log(`[SQLA] Record path is '${path}'`)
+      Backend.info(`[SQLA] Record path is '${path}'`)
 
       return path
    }
 
+   /**
+    * Executes a raw query on the backend.
+    * Only supported by SQL adapters.
+    */
+   async rawQuery(sql: string, params: any[] = []): Promise<any> {
+      const connection = await this._connect()
+      return await connection.all(sql, params)
+   }
+
    protected async _connect(): Promise<Database<sqlite3.Database>> {
       if (!this._connection) {
          // Open SQLite database
@@ -171,7 +178,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          // Add columns based on dataObject properties
          Object.entries(dataObject.properties).forEach(
             ([prop, propDef]: [prop: string, propDef: any]) => {
-               const propName = prop.toLowerCase()
+               const propName = prop
                let columnType = 'TEXT'
 
                // Map property types to SQLite column types
@@ -193,7 +200,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
 
          query += `)`
          await db.exec(query)
-         Backend.log(`[SQLA] Created table ${collection.toLowerCase()}`)
+         Backend.info(`[SQLA] Created table ${collection.toLowerCase()}`)
       }
    }
 
@@ -241,7 +248,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
 
             Object.entries(data).forEach(
                ([key, value]: [key: string, value: any]) => {
-                  columns.push(key.toLowerCase())
+                  columns.push(`"${key}"`)
                   placeholders.push('?')
 
                   // Convert arrays and objects to JSON strings
@@ -294,7 +301,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          )
       }
 
-      Backend.log(`[SQLA] Getting document ${path}`)
+      Backend.info(`[SQLA] Getting document ${path}`)
 
       if (!collection) {
          throw new BackendError(
@@ -325,7 +332,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
             propDef.constructor.name === 'ObjectProperty' &&
             propDef.instanceOf
          ) {
-            const propValue = result[prop.toLowerCase()]
+            const propValue = result[prop]
 
             if (propValue) {
                let refTable = undefined
@@ -351,21 +358,18 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                   }
                }
             }
-         } else if (propDef.constructor.name === 'ArrayProperty') {
-            // Parse JSON arrays
+         } else if (propDef.constructor.name === 'ArrayProperty' || propDef.constructor.name === 'MapProperty') {
+            // Parse JSON arrays and objects
             try {
-               if (result[prop.toLowerCase()]) {
-                  result[prop] = JSON.parse(result[prop.toLowerCase()])
+               if (result[prop]) {
+                  result[prop] = JSON.parse(result[prop])
                }
             } catch (e) {
-               Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`)
+               Backend.warn(`[SQLA] Failed to parse JSON for ${prop}: ${e}`)
             }
          }
 
-         // Normalize property name case
-         if (prop.toLowerCase() !== prop) {
-            result[prop] = result[prop.toLowerCase()]
-         }
+
       }
 
       dataObject.populate(result)
@@ -397,8 +401,6 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          return dataObject
       }
 
-      Backend.debug(`[SQLA] Data to update ${JSON.stringify(data)}`)
-
       const db = await this._connect()
       const collection = this.getCollection(dataObject)
 
@@ -410,7 +412,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
 
       Object.entries(data).forEach(
          ([key, value]: [key: string, value: any]) => {
-            updates.push(`${key.toLowerCase()} = ?`)
+            updates.push(`"${key}" = ?`)
 
             // Convert arrays and objects to JSON strings
             if (
@@ -460,7 +462,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
 
       const db = await this._connect()
 
-      if (!hardDelete) {
+      if (this._params.softDelete !== false && !hardDelete) {
          dataObject.set('status', statuses.DELETED)
          await db.run(
             `UPDATE ${collection.toLowerCase()} SET status = ? WHERE id = ?`,
@@ -551,7 +553,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                   propDef.constructor.name === 'ObjectProperty' &&
                   propDef.instanceOf
                ) {
-                  const propName = prop.toLowerCase()
+                  const propName = prop
                   const joinAlias = `${propName}_table`
 
                   let table = undefined
@@ -590,7 +592,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
             filters.forEach((filter, i) => {
                query.push(parent && i === 0 ? 'AND' : i > 0 ? 'AND' : 'WHERE')
 
-               let realProp: any = filter.prop.toLowerCase()
+               let realProp: any = filter.prop
                let realOperator: string = operatorsMap[filter.operator]
                let realValue = filter.value
 
@@ -600,7 +602,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                   const props = dataObject.getProperties(StringProperty.name)
                   Object.keys(props).forEach((rp) => {
                      keywordFilters.push(
-                        `${collection.toLowerCase()}.${rp.toLowerCase()} LIKE ?`
+                        `${collection.toLowerCase()}.${rp} LIKE ?`
                      )
                      params.push(`%${filter.value as string}%`)
                   })
@@ -619,7 +621,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                   realProp = 'id'
                } else {
                   const property = dataObject.get(filter.prop)
-                  realProp = filter.prop.toLowerCase()
+                  realProp = filter.prop
 
                   if (
                      property.constructor.name === 'ArrayProperty' &&
@@ -765,7 +767,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
             pagination.sortings.forEach((sorting: Sorting, i) => {
                query.push(i === 0 ? `ORDER BY` : ',')
                query.push(
-                  `${collection.toLowerCase()}.${sorting.prop.toLowerCase()} ${
+                  `${collection.toLowerCase()}.${sorting.prop} ${
                      sorting.order
                   }`
                )
@@ -805,19 +807,17 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          for (let doc of results || []) {
             // Process document before populating
             Object.entries(dataObject.properties).forEach(([prop, propDef]: [prop: string, propDef: any]) => {
-               const lcProp = prop.toLowerCase()
-
                // Handle ObjectProperty references
                if (
                   propDef.constructor.name === 'ObjectProperty' &&
                   propDef.instanceOf
                ) {
-                  const refValue = doc[lcProp]
+                  const refValue = doc[prop]
                   if (refValue) {
                      const info = joinTables[prop]
                      
                      if (info) {
-                        const label = doc[`${lcProp}_table_name`] || ''
+                        const label = doc[`${prop}_table_name`] || ''
 
                         doc[prop] = {
                            ref: `${info.table}/${refValue}`,
@@ -844,25 +844,25 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                      }
                   }
                }
-               // Handle array properties
-               else if (propDef.constructor.name === 'ArrayProperty') {
+               // Handle array and map properties
+               else if (propDef.constructor.name === 'ArrayProperty' || propDef.constructor.name === 'MapProperty') {
                   try {
-                     if (doc[lcProp]) {
-                        doc[prop] = JSON.parse(doc[lcProp])
+                     if (doc[prop] && typeof doc[prop] === 'string') {
+                        doc[prop] = JSON.parse(doc[prop])
                      }
                   } catch (e) {
                      Backend.warn(
-                        `[SQLA] Failed to parse array for ${prop}: ${e}`
+                        `[SQLA] Failed to parse JSON for ${prop}: ${e}`
                      )
                   }
                }
-
-               // Ensure property is available with original case
-               if (prop !== lcProp) {
-                  doc[prop] = doc[lcProp]
-               }
             })
 
+            // Map SQLite 'id' column back to Quatrain 'uid' property
+            if (doc.id && !doc.uid) {
+               doc.uid = doc.id
+            }
+
             const newDataObject: DataObjectClass<any> = await dataObject.clone({
                ...doc,
             })
@@ -913,4 +913,81 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
          this._connection = undefined
       }
    }
+
+   /**
+    * Generates the SQL up and down statements to create a collection table.
+    */
+   generateCreateSql(collection: string, properties: any[]): { upSql: string; downSql: string } {
+      let query = `CREATE TABLE IF NOT EXISTS "${collection.toLowerCase()}" (\n    id TEXT PRIMARY KEY`
+
+      properties.forEach((propDef: any) => {
+         const propName = propDef.name
+         let columnType = 'TEXT'
+
+         const type = propDef.type || propDef.constructor.name
+         if (type === 'NumberProperty') {
+            columnType = 'REAL'
+         } else if (type === 'BooleanProperty') {
+            columnType = 'INTEGER'
+         } else if (type === 'DateTimeProperty') {
+            columnType = 'INTEGER'
+         } else if (type === 'ArrayProperty') {
+            columnType = 'TEXT'
+         } else if (type === 'ObjectProperty') {
+            columnType = 'TEXT'
+         }
+
+         query += `,\n    "${propName}" ${columnType}`
+      })
+
+      query += `\n)`
+
+      return {
+         upSql: `await adapter.rawQuery(\`${query}\`)`,
+         downSql: `await adapter.rawQuery(\`DROP TABLE IF EXISTS "${collection.toLowerCase()}"\`)`,
+      }
+   }
+
+   /**
+    * Generates the SQL up and down statements to apply a schema delta to a collection.
+    */
+   generateDeltaSql(collection: string, delta: any): { upSql: string[]; downSql: string[] } {
+      const upSql: string[] = []
+      const downSql: string[] = []
+
+      // Added columns
+      delta.added.forEach((propDef: any) => {
+         const propName = propDef.name
+         let columnType = 'TEXT'
+
+         const type = propDef.type || propDef.constructor.name
+         if (type === 'NumberProperty') {
+            columnType = 'REAL'
+         } else if (type === 'BooleanProperty') {
+            columnType = 'INTEGER'
+         } else if (type === 'DateTimeProperty') {
+            columnType = 'INTEGER'
+         }
+
+         upSql.push(`await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" ADD COLUMN "${propName}" ${columnType}\`)`)
+         // SQLite < 3.35 doesn't support DROP COLUMN, so we add a comment but keep the syntax
+         downSql.push(`// NOTE: DROP COLUMN requires SQLite >= 3.35\n   // await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" DROP COLUMN "${propName}"\`)`)
+      })
+
+      // Removed columns
+      delta.removed.forEach((propDef: any) => {
+         const propName = propDef.name
+         let columnType = 'TEXT'
+         
+         const type = propDef.type || propDef.constructor.name
+         if (type === 'NumberProperty') columnType = 'REAL'
+         else if (type === 'BooleanProperty') columnType = 'INTEGER'
+         else if (type === 'DateTimeProperty') columnType = 'INTEGER'
+
+         upSql.push(`// NOTE: DROP COLUMN requires SQLite >= 3.35\n   // await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" DROP COLUMN "${propName}"\`)`)
+         downSql.push(`await adapter.rawQuery(\`ALTER TABLE "${collection.toLowerCase()}" ADD COLUMN "${propName}" ${columnType}\`)`)
+      })
+
+      return { upSql, downSql }
+   }
 }

package/src/__test__/SQLiteAdapter.test.ts

@@ -123,6 +123,20 @@ describe('SQLiteAdapter Tests', () => {
          expect(result.val('email')).toBe('john@doe.com')
       })
 
+      test('should correctly map SQLite id column back to Quatrain uid property', async () => {
+         const db = await (adapter as any)._connect()
+         // Vérifier que la colonne id existe bien en base
+         const rawData = await db.get(`SELECT id, firstname FROM user WHERE id = ?`, [user.uid])
+         expect(rawData.id).toBeDefined()
+         expect((rawData as any).uid).toBeUndefined() // SQLite ne stocke pas de colonne uid
+
+         // Vérifier que l'adaptateur remonte bien la valeur dans la propriété uid
+         const readUser = await User.factory()
+         readUser.dataObject.uri.path = user.dataObject.uri.path
+         const result = await adapter.read(readUser.dataObject)
+         expect(result.uid).toBe(rawData.id)
+      })
+
       test('should throw NotFoundError for non-existent record', async () => {
          const nonExistentUser = await User.factory()
          nonExistentUser.dataObject.uri.path = 'user/non-existent-id'