@quatrain/backend-sqlite 1.0.16 → 1.1.1

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) {
@@ -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.toLowerCase()}"`);
                         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`);
             }
@@ -273,15 +283,15 @@ 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()]);
                         }
                     }
                     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
@@ -312,7 +322,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 +329,7 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
             let updates = [];
             let values = [];
             Object.entries(data).forEach(([key, value]) => {
-                updates.push(`${key.toLowerCase()} = ?`);
+                updates.push(`"${key.toLowerCase()}" = ?`);
                 // Convert arrays and objects to JSON strings
                 if (Array.isArray(value) ||
                     (typeof value === 'object' && value !== null)) {
@@ -353,7 +362,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]);
             }
@@ -643,15 +652,15 @@ 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]);
                                 }
                             }
                             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
@@ -659,6 +668,10 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
                             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 +705,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.toLowerCase();
+            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.toLowerCase();
+            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.toLowerCase();
+            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.1",
   "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.0",
     "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
@@ -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.toLowerCase()}"`)
                   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(
@@ -351,14 +358,14 @@ 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()])
                }
             } catch (e) {
-               Backend.warn(`[SQLA] Failed to parse array for ${prop}: ${e}`)
+               Backend.warn(`[SQLA] Failed to parse JSON for ${prop}: ${e}`)
             }
          }
 
@@ -397,8 +404,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 +415,7 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
 
       Object.entries(data).forEach(
          ([key, value]: [key: string, value: any]) => {
-            updates.push(`${key.toLowerCase()} = ?`)
+            updates.push(`"${key.toLowerCase()}" = ?`)
 
             // Convert arrays and objects to JSON strings
             if (
@@ -460,7 +465,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 = ?`,
@@ -844,15 +849,15 @@ 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])
                      }
                   } catch (e) {
                      Backend.warn(
-                        `[SQLA] Failed to parse array for ${prop}: ${e}`
+                        `[SQLA] Failed to parse JSON for ${prop}: ${e}`
                      )
                   }
                }
@@ -863,6 +868,11 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
                }
             })
 
+            // 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 +923,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.toLowerCase()
+         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.toLowerCase()
+         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.toLowerCase()
+         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'