@oino-ts/db 0.6.1 → 0.7.0

package/src/OINODbApi.ts

@@ -162,6 +162,9 @@ export class OINODbHtmlTemplate extends OINOHtmlTemplate {
  *
  */
 export class OINODbApi {
+    /** Enable debug output on errors */
+    private _debugOnError:boolean = false
+
     /** API database reference */
     readonly db: OINODb
 
@@ -197,7 +200,19 @@ export class OINODbApi {
         }
     }
 
-    private _validateRowValues(httpResult:OINODbApiResult, row:OINODataRow, requirePrimaryKey:boolean):void {
+    private _printSql(result: OINODbApiResult, rows: OINODataRow[], requirePrimaryKey: boolean, printer: (row: OINODataRow) => string): string {
+        let sql = "";
+        for (let i = 0; i < rows.length; i++) {
+            this._validateRow(result, rows[i], requirePrimaryKey);
+            if (result.success) {
+                sql += printer(rows[i]);
+            } else if (this.params.failOnAnyInvalidRows === false) {
+                result.setOk(); // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+            }
+        }
+        return sql;
+    }
+    private _validateRow(result:OINODbApiResult, row:OINODataRow, requirePrimaryKey:boolean):void {
         let field:OINODbDataField
         for (let i=0; i<this.datamodel.fields.length; i++) {
             field = this.datamodel.fields[i]
@@ -205,13 +220,13 @@ export class OINODbApi {
             const val:OINODataCell = row[i]
             // OINOLog.debug("OINODbApi.validateHttpValues", {val:val})
             if ((val === null) && ((field.fieldParams.isNotNull)||(field.fieldParams.isPrimaryKey))) { // null is a valid SQL value except if it's not allowed
-                httpResult.setError(405, "Field '" + field.name + "' is not allowed to be NULL!", "ValidateRowValues")
+                result.setError(405, "Field '" + field.name + "' is not allowed to be NULL!", "ValidateRowValues")
 
             } else if ((val === undefined) && (requirePrimaryKey) && (field.fieldParams.isPrimaryKey) && (!field.fieldParams.isAutoInc)) { 
-                httpResult.setError(405, "Primary key '" + field.name + "' is not autoinc and missing from the data!", "ValidateRowValues")
+                result.setError(405, "Primary key '" + field.name + "' is not autoinc and missing from the data!", "ValidateRowValues")
 
             } else if ((val !== undefined) && (this.params.failOnUpdateOnAutoinc) && (field.fieldParams.isAutoInc)) { 
-                httpResult.setError(405, "Autoinc field '" + field.name + "' can't be updated!", "ValidateRowValues")
+                result.setError(405, "Autoinc field '" + field.name + "' can't be updated!", "ValidateRowValues")
 
             } else {
                 if ((field instanceof OINOStringDataField) && ((field.maxLength > 0))){
@@ -219,9 +234,9 @@ export class OINODbApi {
                     // OINOLog.debug("OINODbApi.validateHttpValues", {f:str_field, val:val})
                     if (str_val.length > field.maxLength) {
                         if (this.params.failOnOversizedValues) {
-                            httpResult.setError(405, "Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and can't be set!", "ValidateRowValues")
+                            result.setError(405, "Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and can't be set!", "ValidateRowValues")
                         } else {
-                            httpResult.addWarning("Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and might truncate or fail.", "ValidateRowValues")
+                            result.addWarning("Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and might truncate or fail.", "ValidateRowValues")
                         }
                     }
                 }
@@ -231,6 +246,21 @@ export class OINODbApi {
         //logDebug("OINODbApi.validateHttpValues", {result:result})
     }
 
+    private _parseData(httpResult:OINODbApiResult, body:string|OINODataRow[]|Buffer|any, params:OINODbApiRequestParams):OINODataRow[] {
+        let rows:OINODataRow[] = []
+        try {
+            if (Array.isArray(body)) {
+                rows = body as OINODataRow[]
+            } else {
+                rows = OINODbParser.createRows(this.datamodel, body, params)
+            }
+        
+        } catch (e:any) {
+            httpResult.setError(400, "Invalid data: " + e.message, "DoRequest")
+        }
+        return rows
+    }
+
     private async _doGet(result:OINODbApiResult, id:string, params:OINODbApiRequestParams):Promise<void> {
         let sql:string = ""
         try {
@@ -253,27 +283,28 @@ export class OINODbApi {
     private async _doPost(result:OINODbApiResult, rows:OINODataRow[]):Promise<void> {
         let sql:string = "" 
         try {
-            let i:number = 0
-            while (i<rows.length) {
-                this._validateRowValues(result, rows[i], this.params.failOnInsertWithoutKey||false)
+            for (let i=0; i<rows.length; i++) {
+                this._validateRow(result, rows[i], this.params.failOnInsertWithoutKey||false)
                 if (result.success) {
                     sql += this.datamodel.printSqlInsert(rows[i]) 
+
+                } else if (this.params.failOnAnyInvalidRows == false) {
+                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
                 }
-                result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
-                i++
             }
-            if (sql == "") {
+            if ((sql == "") && result.success) {
                 result.setError(405, "No valid rows for POST!", "DoPost")
-                result.addDebug("OINO POST DATA [" + rows.join("|") + "]", "DoPost")
 
-            } else {
+            } else if (result.success) {
                 // OINOLog.debug("OINODbApi.doPost sql", {sql:sql})
                 const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
                 // OINOLog.debug("OINODbApi.doPost sql_res", {sql_res:sql_res})
                 if (sql_res.hasErrors()) {
                     result.setError(500, sql_res.getFirstError(), "DoPost")
-                    result.addDebug("OINO POST MESSAGES [" + sql_res.messages.join('|') + "]", "DoPost")
-                    result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO POST MESSAGES [" + sql_res.messages.join('|') + "]", "DoPost")
+                        result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")                
+                    }
                 }
             }
         } catch (e:any) {
@@ -282,19 +313,33 @@ export class OINODbApi {
         }
     }
 
-    private async _doPut(result:OINODbApiResult, id:string, row:OINODataRow):Promise<void> {
+    private async _doPut(result:OINODbApiResult, id:string|null, rows:OINODataRow[]):Promise<void> {
         let sql:string = ""
         try {
-            this._validateRowValues(result, row, false)
-            if (result.success) {
-                sql = this.datamodel.printSqlUpdate(id, row)
+            // this._validateRowValues(result, row, false)
+            for (let i=0; i<rows.length; i++) {
+                const row_id = id || OINODbConfig.printOINOId(this.datamodel.getRowPrimarykeyValues(rows[i], this.hashid != null))
+                this._validateRow(result, rows[i], this.params.failOnInsertWithoutKey||false)
+                if (result.success) {
+                    sql += this.datamodel.printSqlUpdate(row_id, rows[i]) 
+
+                } else if (this.params.failOnAnyInvalidRows == false) {
+                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                }
+            }
+            if ((sql == "") && result.success) {
+                result.setError(405, "No valid rows for PUT!", "DoPut") // only set error if there are multiple rows and no valid sql was created
+
+            } else if (result.success) {
                 // OINOLog.debug("OINODbApi.doPut sql", {sql:sql})
                 const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
                 // OINOLog.debug("OINODbApi.doPut sql_res", {sql_res:sql_res})
                 if (sql_res.hasErrors()) {
                     result.setError(500, sql_res.getFirstError(), "DoPut")
-                    result.addDebug("OINO PUT MESSAGES [" + sql_res.messages.join('|') + "]", "DoPut")
-                    result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO PUT MESSAGES [" + sql_res.messages.join('|') + "]", "DoPut")
+                        result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
+                    }
                 }
             }
         } catch (e:any) {
@@ -303,17 +348,36 @@ export class OINODbApi {
         }
     }
 
-    private async _doDelete(result:OINODbApiResult, id:string):Promise<void> {
+    private async _doDelete(result:OINODbApiResult, id:string|null, rows:OINODataRow[]|null):Promise<void> {
         let sql:string = ""
         try {
-            sql = this.datamodel.printSqlDelete(id)
-            // OINOLog.debug("OINODbApi.doDelete sql", {sql:sql})
-            const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
-            // OINOLog.debug("OINODbApi.doDelete sql_res", {sql_res:sql_res})
-            if (sql_res.hasErrors()) {
-                result.setError(500, sql_res.getFirstError(), "DoDelete")
-                result.addDebug("OINO DELETE MESSAGES [" + sql_res.messages.join('|') + "]", "DoDelete")
-                result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")
+            if (rows != null) {
+                for (let i=0; i<rows.length; i++) {
+                    const row_id = OINODbConfig.printOINOId(this.datamodel.getRowPrimarykeyValues(rows[i], this.hashid != null))
+                    if (row_id) {
+                        sql += this.datamodel.printSqlDelete(row_id) 
+                    } else if (this.params.failOnAnyInvalidRows == false) {
+                        result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                    }
+                }
+            } else if (id) {
+                sql = this.datamodel.printSqlDelete(id)
+            }
+            if ((sql == "") && result.success) {
+                result.setError(405, "No valid rows for DELETE!", "DoDelete") // only set error if there are multiple rows and no valid sql was created
+
+            } else if (result.success) {
+            
+                // OINOLog.debug("OINODbApi.doDelete sql", {sql:sql})
+                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
+                // OINOLog.debug("OINODbApi.doDelete sql_res", {sql_res:sql_res})
+                if (sql_res.hasErrors()) {
+                    result.setError(500, sql_res.getFirstError(), "DoDelete")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO DELETE MESSAGES [" + sql_res.messages.join('|') + "]", "DoDelete")
+                        result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")                    
+                    }
+                }
             }
         } catch (e:any) {
             result.setError(500, "Unhandled exception: " + e.message, "DoDelete")
@@ -321,33 +385,32 @@ export class OINODbApi {
         }
     }
 
+    /**
+     * Enable or disable debug output on errors.
+     * 
+     * @param debugOnError true to enable debug output on errors, false to disable
+     */
+    setDebugOnError(debugOnError:boolean) {
+        this._debugOnError = debugOnError
+    }
+
     /**
      * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
      * SQL select, insert, update and delete.
      * 
      * @param method HTTP verb (uppercase)
      * @param id URL id of the REST request
-     * @param body HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
+     * @param data HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
      * @param params HTTP URL parameters as key-value-pairs
      *
      */
-    async doRequest(method:string, id: string, body:string|OINODataRow[]|Buffer|any, params:OINODbApiRequestParams = API_EMPTY_PARAMS):Promise<OINODbApiResult> {
+    async doRequest(method:string, id: string, data:string|OINODataRow[]|Buffer|any, params:OINODbApiRequestParams = API_EMPTY_PARAMS):Promise<OINODbApiResult> {
         OINOBenchmark.start("OINODbApi", "doRequest")
         // OINOLog.debug("OINODbApi.doRequest enter", {method:method, id:id, body:body, params:params})
         let result:OINODbApiResult = new OINODbApiResult(params)
         let rows:OINODataRow[] = []
         if ((method == "POST") || (method == "PUT")) {
-            try {
-                if (Array.isArray(body)) {
-                    rows = body as OINODataRow[]
-                } else {
-                    rows = OINODbParser.createRows(this.datamodel, body, params)
-                }
-            
-            } catch (e:any) {
-                result.setError(400, "Invalid data: " + e.message, "DoRequest")
-            }
-            // OINOLog.debug("OINODbApi.doRequest - OINODataRow rows", {rows:rows})        
+            rows = this._parseData(result, data, params)
         }
         if (method == "GET") {
             await this._doGet(result, id, params)
@@ -361,7 +424,7 @@ export class OINODbApi {
     
             } else {
                 try {
-                    await this._doPut(result, id, rows[0])
+                    await this._doPut(result, id, rows)
 
                 } catch (e:any) {
                     result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoRequest")
@@ -389,19 +452,59 @@ export class OINODbApi {
 
             } else {
                 try {
-                    await this._doDelete(result, id)
+                    await this._doDelete(result, id, null)
 
                 } catch (e:any) {
                     result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoRequest")
                 }
             }
         } else {
-            result.setError(405, "Unsupported HTTP method '" + method + "'", "DoRequest")
+            result.setError(405, "Unsupported HTTP method '" + method + "' for REST request", "DoRequest")
         }
         OINOBenchmark.end("OINODbApi", "doRequest", method)
         return Promise.resolve(result)
     }
 
+    /**
+     * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     * 
+     * @param method HTTP verb (uppercase)
+     * @param data HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
+     * @param params HTTP URL parameters as key-value-pairs
+     *
+     */
+    async doBatchUpdate(method:string, data:string|OINODataRow[]|Buffer|any, params:OINODbApiRequestParams = API_EMPTY_PARAMS):Promise<OINODbApiResult> {
+        OINOBenchmark.start("OINODbApi", "doBatchUpdate")
+        // OINOLog.debug("OINODbApi.doRequest enter", {method:method, id:id, body:body, params:params})
+        let result:OINODbApiResult = new OINODbApiResult(params)
+        let rows:OINODataRow[] = []
+        if ((method == "PUT")) {
+            rows = this._parseData(result, data, params)
+        }
+        if (method == "PUT") {
+
+            try {
+                await this._doPut(result, null, rows)
+
+            } catch (e:any) {
+                result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoBatchUpdate")
+            }             
+
+        } else if (method == "DELETE") {
+            try {
+                await this._doDelete(result, null, rows)
+
+            } catch (e:any) {
+                result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoBatchUpdate")
+            }
+        } else {
+            result.setError(405, "Unsupported HTTP method '" + method + "' for batch update", "DoBatchUpdate")
+        }
+        OINOBenchmark.end("OINODbApi", "doBatchUpdate", method)
+        return Promise.resolve(result)
+    }
+
     /**
      * Method to check if a field is included in the API params.
      *

package/src/OINODbDataModel.ts

@@ -103,6 +103,7 @@ export class OINODbDataModel {
                 if ((f instanceof OINONumberDataField) && (this.api.hashid)) {
                     value = this.api.hashid.decode(value)
                 }
+                // OINOLog.debug("OINODbDataModel._printSqlPrimaryKeyCondition", {field:f.name, value:value, id_value:id_value})
                 result += f.printSqlColumnName() + "=" + f.printCellAsSqlValue(value); 
                 i = i + 1
             }
@@ -279,6 +280,7 @@ export class OINODbDataModel {
      */
     printSqlUpdate(id: string, row: OINODataRow): string {
         let result: string = "UPDATE " + this.api.db.printSqlTablename(this.api.params.tableName) + " SET " + this._printSqlUpdateValues(row) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        // OINOLog.debug("OINODbDataModel.printSqlUpdate", {result:result, id:id, row:row})
         return result;
     }
 

package/src/index.ts

@@ -30,6 +30,8 @@ export type OINODbApiParams = {
     failOnUpdateOnAutoinc?: boolean
     /** Reject POST-requests without primary key value (can work if DB-side ) */
     failOnInsertWithoutKey?: boolean
+    /** Reject POST-requests without primary key value (can work if DB-side ) */
+    failOnAnyInvalidRows?: boolean
     /** Treat date type fields as just strings and use the native formatting instead of the ISO 8601 format */
     useDatesAsString?: Boolean
     /** Include given fields from the API and exclude rest (if defined) */