@quatrain/backend-sqlite 1.1.5 → 1.1.6

package/dist/SQLiteAdapter.js

@@ -182,63 +182,61 @@ class SQLiteAdapter extends backend_1.AbstractBackendAdapter {
      */
     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, node_crypto_1.randomUUID)();
-                    // Make sure table exists
-                    yield this._ensureTable(dataObject);
-                    // Set uid before middlewares so they can use it
-                    dataObject.uri.path = this._buildPath(dataObject, uid);
-                    // execute middlewares
-                    yield this.executeMiddlewares(dataObject, backend_1.BackendAction.CREATE, 'before', {
-                        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}"`);
-                        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);
-                    // uri.path is already set before middlewares
-                    dataObject.uri.label = data && Reflect.get(data, 'name');
-                    dataObject.isPersisted(true);
-                    backend_1.Backend.info(`[SQLA] Saved object "${data.name}" at path ${dataObject.path}`);
-                    yield this.executeMiddlewares(dataObject, backend_1.BackendAction.CREATE, 'after', {
-                        useDateFormat: true,
-                    });
-                    resolve(dataObject);
-                }
-                catch (err) {
-                    console.error(err);
-                    backend_1.Backend.error(err.message);
-                    reject(new backend_1.BackendError(err.message));
+            try {
+                if (dataObject.uid) {
+                    throw new backend_1.BackendError(`Data object already has an uid and can't be created`);
                 }
-            }));
+                const uid = desiredUid || (0, node_crypto_1.randomUUID)();
+                // Make sure table exists
+                yield this._ensureTable(dataObject);
+                // Set uid before middlewares so they can use it
+                dataObject.uri.path = this._buildPath(dataObject, uid);
+                // execute middlewares
+                yield this.executeMiddlewares(dataObject, backend_1.BackendAction.CREATE, 'before', {
+                    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}"`);
+                    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);
+                // uri.path is already set before middlewares
+                dataObject.uri.label = data && Reflect.get(data, 'name');
+                dataObject.isPersisted(true);
+                backend_1.Backend.info(`[SQLA] Saved object "${data.name}" at path ${dataObject.path}`);
+                yield this.executeMiddlewares(dataObject, backend_1.BackendAction.CREATE, 'after', {
+                    useDateFormat: true,
+                });
+                return dataObject;
+            }
+            catch (err) {
+                console.error(err);
+                backend_1.Backend.error(err.message);
+                throw new backend_1.BackendError(err.message);
+            }
         });
     }
     read(dataObject) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/backend-sqlite",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "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.2.3",
-    "@quatrain/core": "^1.2.4",
+    "@quatrain/backend": "^1.2.4",
+    "@quatrain/core": "^1.2.5",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7"
   },

package/src/SQLiteAdapter.ts

@@ -214,87 +214,85 @@ export class SQLiteAdapter extends AbstractBackendAdapter {
       dataObject: DataObjectClass<any>,
       desiredUid: string | undefined
    ): Promise<DataObjectClass<any>> {
-      return new Promise(async (resolve, reject) => {
-         try {
-            if (dataObject.uid) {
-               throw new BackendError(
-                  `Data object already has an uid and can't be created`
-               )
-            }
+      try {
+         if (dataObject.uid) {
+            throw new BackendError(
+               `Data object already has an uid and can't be created`
+            )
+         }
 
-            const uid = desiredUid || randomUUID()
+         const uid = desiredUid || randomUUID()
 
-            // Make sure table exists
-            await this._ensureTable(dataObject)
+         // Make sure table exists
+         await this._ensureTable(dataObject)
 
-            // Set uid before middlewares so they can use it
-            dataObject.uri.path = this._buildPath(dataObject, uid)
+         // Set uid before middlewares so they can use it
+         dataObject.uri.path = this._buildPath(dataObject, uid)
 
-            // execute middlewares
-            await this.executeMiddlewares(dataObject, BackendAction.CREATE, 'before', {
-               useDateFormat: true,
-            })
+         // execute middlewares
+         await this.executeMiddlewares(dataObject, BackendAction.CREATE, 'before', {
+            useDateFormat: true,
+         })
 
-            const data = dataObject.toJSON({
-               withoutURIData: true,
-               converters: {
-                  datetime: (v: any) => (v ? new Date(v).getTime() : v), // Store as timestamp in SQLite
-               },
-            })
+         const data = dataObject.toJSON({
+            withoutURIData: true,
+            converters: {
+               datetime: (v: any) => (v ? new Date(v).getTime() : v), // Store as timestamp in SQLite
+            },
+         })
 
-            const db = await this._connect()
-            const collection = this.getCollection(dataObject)
+         const db = await this._connect()
+         const collection = this.getCollection(dataObject)
 
-            let columns = ['id']
-            let placeholders = ['?']
-            let values = [uid]
+         let columns = ['id']
+         let placeholders = ['?']
+         let values = [uid]
 
-            Object.entries(data).forEach(
-               ([key, value]: [key: string, value: any]) => {
-                  columns.push(`"${key}"`)
-                  placeholders.push('?')
+         Object.entries(data).forEach(
+            ([key, value]: [key: string, value: any]) => {
+               columns.push(`"${key}"`)
+               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)
-                  }
+               // 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?.toLowerCase()} (${columns.join(
-               ', '
-            )})
-                           VALUES (${placeholders.join(', ')})`
+         const query = `INSERT INTO ${collection?.toLowerCase()} (${columns.join(
+            ', '
+         )})
+                        VALUES (${placeholders.join(', ')})`
 
-            Backend.debug(`[SQLA] ${query}`)
-            Backend.debug(`[SQLA] Values ${JSON.stringify(values)}`)
+         Backend.debug(`[SQLA] ${query}`)
+         Backend.debug(`[SQLA] Values ${JSON.stringify(values)}`)
 
-            await db.run(query, values)
+         await db.run(query, values)
 
-            // uri.path is already set before middlewares
-            dataObject.uri.label = data && Reflect.get(data, 'name')
-            dataObject.isPersisted(true)
+         // uri.path is already set before middlewares
+         dataObject.uri.label = data && Reflect.get(data, 'name')
+         dataObject.isPersisted(true)
 
-            Backend.info(
-               `[SQLA] Saved object "${data.name}" at path ${dataObject.path}`
-            )
+         Backend.info(
+            `[SQLA] Saved object "${data.name}" at path ${dataObject.path}`
+         )
 
-            await this.executeMiddlewares(dataObject, BackendAction.CREATE, 'after', {
-               useDateFormat: true,
-            })
+         await this.executeMiddlewares(dataObject, BackendAction.CREATE, 'after', {
+            useDateFormat: true,
+         })
 
-            resolve(dataObject)
-         } catch (err) {
-            console.error(err)
-            Backend.error((err as Error).message)
-            reject(new BackendError((err as Error).message))
-         }
-      })
+         return dataObject
+      } catch (err) {
+         console.error(err)
+         Backend.error((err as Error).message)
+         throw new BackendError((err as Error).message)
+      }
    }
 
    async read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>> {

package/src/__test__/SQLiteAdapter.test.ts

@@ -208,7 +208,7 @@ describe('SQLiteAdapter Tests', () => {
             testUser._.firstname = `SearchUser${i}`
             testUser._.lastname = 'SearchTest'
             testUser._.email = `searchuser${i}@test.com`
-            testUser._.password = 'password'
+            testUser._.password = 'password' // NOSONAR
             await adapter.create(testUser.dataObject, undefined)
          }
       })
@@ -314,7 +314,7 @@ describe('SQLiteAdapter Tests', () => {
          newUser._.firstname = 'Auto'
          newUser._.lastname = 'Table'
          newUser._.email = 'auto@table.com'
-         newUser._.password = 'password'
+         newUser._.password = 'password' // NOSONAR
          
          // This should automatically create the table
          const result = await adapter.create(newUser.dataObject, undefined)
@@ -327,7 +327,7 @@ describe('SQLiteAdapter Tests', () => {
          user._.firstname = 'Table'
          user._.lastname = 'Exists'
          user._.email = 'table@exists.com'
-         user._.password = 'password'
+         user._.password = 'password' // NOSONAR
          
          await adapter.create(user.dataObject, undefined)
          
@@ -404,7 +404,7 @@ describe('SQLiteAdapter Tests', () => {
          testUser._.firstname = 'Ref'
          testUser._.lastname = 'Test'
          testUser._.email = 'ref@test.com'
-         testUser._.password = 'password'
+         testUser._.password = 'password' // NOSONAR
          testUser._.entity = entity
          
          const result = await adapter.create(testUser.dataObject, undefined)

package/src/__test__/Search.test.ts

@@ -21,7 +21,7 @@ describe('SQLite Search Operations', () => {
          testUser._.firstname = `TestUser${i}`
          testUser._.lastname = i % 2 === 0 ? 'Even' : 'Odd'
          testUser._.email = `testuser${i}@example.com`
-         testUser._.password = 'password'
+         testUser._.password = 'password' // NOSONAR
          
          // Some users belong to the entity
          if (i < 5) {