forge-sql-orm 1.0.24 → 1.0.26

package/src/core/ForgeSQLQueryBuilder.ts

@@ -1,8 +1,10 @@
 import { UpdateQueryResponse } from "@forge/sql";
-import type { EntityName, LoggingOptions } from "..";
+import type { EntityName, LoggingOptions, QBFilterQuery } from "..";
 import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
 import type { QueryBuilder } from "@mikro-orm/knex/query";
 import type { Knex } from "knex";
+import { EntityKey } from "@mikro-orm/core";
+import {SqlParameters} from "@forge/sql/out/sql-statement";
 
 /**
  * Interface representing the main ForgeSQL operations.
@@ -27,6 +29,10 @@ export interface ForgeSqlOrmOptions {
    * Enables logging of raw SQL queries in the Atlassian Forge Developer Console.
    */
   logRawSqlQuery?: boolean;
+  /**
+   * Disable optimistic locking
+   */
+  disableOptimisticLocking?: boolean
 }
 
 /**
@@ -41,6 +47,14 @@ export interface SchemaSqlForgeSql {
    */
   executeSchemaSQL<T extends object>(query: string, schema: EntitySchema<T>): Promise<T[]>;
 
+  /**
+   * Executes a schema-bound SQL query and maps the only one result to the specified entity schema.
+   * @param query - The SQL query to execute.
+   * @param schema - The entity schema.
+   * @returns A list of mapped entity objects.
+   */
+  executeSchemaSQLOnlyOne<T extends object>(query: string, schema: EntitySchema<T>): Promise<T|undefined>;
+
   /**
    * Executes a raw SQL query and returns the results.
    * @param query - The raw SQL query.
@@ -51,9 +65,11 @@ export interface SchemaSqlForgeSql {
   /**
    * Executes a raw SQL update query.
    * @param query - The raw SQL update query.
+   * @param params - Sql parameters.
    * @returns The update response containing affected rows.
    */
-  executeRawUpdateSQL(query: string): Promise<UpdateQueryResponse>;
+  executeRawUpdateSQL(query: string, params?: SqlParameters[]): Promise<UpdateQueryResponse>;
+
 }
 
 /**
@@ -83,10 +99,52 @@ export interface CRUDForgeSQL {
 
   /**
    * Updates a record by its ID.
+   *   * If a version field is defined in the schema, versioning is applied:
+   *    * the current record version is retrieved, checked for concurrent modifications,
+   *    * and then incremented.
+   *    *
+   *    * @param entity - The entity with updated values.
+   *    * @param schema - The entity schema.
+   *    * @throws If the primary key is not included in the update fields.
+   *    */
+  updateById<T extends object>(entity: Partial<T>, schema: EntitySchema<T>): Promise<void>;
+
+  /**
+   * Updates specified fields of records based on provided conditions.
+   * If the "where" parameter is not provided, the WHERE clause is built from the entity fields
+   * that are not included in the list of fields to update.
+   *
+   * @param entity - The object containing values to update and potential criteria for filtering.
+   * @param fields - Array of field names to update.
+   * @param schema - The entity schema.
+   * @param where - Optional filtering conditions for the WHERE clause.
+   * @returns The number of affected rows.
+   * @throws If no filtering criteria are provided (either via "where" or from the remaining entity fields).
+   */
+   updateFields<T extends object>(
+      entity: Partial<T>,
+      fields: EntityKey<T>[],
+      schema: EntitySchema<T>,
+      where?: QBFilterQuery<T>,
+  ): Promise<number>
+
+  /**
+   * Updates specific fields of a record identified by its primary key.
+   *
+   * If a version field is defined in the schema, versioning is applied:
+   * the current record version is retrieved, checked for concurrent modifications,
+   * and then incremented.
+   *
    * @param entity - The entity with updated values.
+   * @param fields - The list of field names to update.
    * @param schema - The entity schema.
+   * @throws If the primary key is not included in the update fields.
    */
-  updateById<T extends object>(entity: T, schema: EntitySchema<T>): Promise<void>;
+  updateFieldById<T extends object>(
+    entity: T,
+    fields: EntityKey<T>[],
+    schema: EntitySchema<T>,
+  ): Promise<void>;
 }
 
 /**

package/src/core/ForgeSQLSelectOperations.ts

@@ -2,6 +2,7 @@ import { sql, UpdateQueryResponse } from "@forge/sql";
 import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
 import { parseDateTime } from "../utils/sqlUtils";
 import { ForgeSqlOrmOptions, SchemaSqlForgeSql } from "./ForgeSQLQueryBuilder";
+import {SqlParameters} from "@forge/sql/out/sql-statement";
 
 export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
   private readonly options: ForgeSqlOrmOptions;
@@ -10,6 +11,17 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
     this.options = options;
   }
 
+  async executeSchemaSQLOnlyOne<T extends object>(query: string, schema: EntitySchema<T>): Promise<T|undefined> {
+        const results = await this.executeSchemaSQL(query, schema);
+        if (!results || results.length === 0){
+          return undefined;
+        }
+        if (results.length>1){
+          throw new Error('Expected 1 record but returned '+results.length)
+        }
+        return results[0];
+    }
+
   /**
    * Executes a schema-based SQL query and maps the result to the entity schema.
    * @param query - The SQL query to execute.
@@ -33,10 +45,10 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
 
           switch (p.type) {
             case "datetime":
-              newModel[fieldName] = parseDateTime(
-                rawModel[rawFieldName] as string,
-                "YYYY-MM-DDTHH:mm:ss.SSS",
-              );
+                newModel[fieldName] = parseDateTime(
+                    rawModel[rawFieldName] as string,
+                    "YYYY-MM-DDTHH:mm:ss.SSS",
+                );
               break;
             case "date":
               newModel[fieldName] = parseDateTime(rawModel[rawFieldName] as string, "YYYY-MM-DD");
@@ -68,13 +80,14 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
   /**
    * Executes a raw SQL update query.
    * @param query - The raw SQL update query.
+   * @param params - sql parameters.
    * @returns The update response containing affected rows.
    */
-  async executeRawUpdateSQL(query: string): Promise<UpdateQueryResponse> {
-    if (this.options.logRawSqlQuery) {
-      console.debug("Executing update SQL: " + query);
-    }
+  async executeRawUpdateSQL(query: string, params?: SqlParameters[]): Promise<UpdateQueryResponse> {
     const sqlStatement = sql.prepare<UpdateQueryResponse>(query);
+    if (params) {
+      sqlStatement.bindParams(params);
+    }
     const updateQueryResponseResults = await sqlStatement.execute();
     return updateQueryResponseResults.rows;
   }

package/src/utils/sqlUtils.ts

@@ -2,24 +2,33 @@ import { types } from "@mikro-orm/core/types";
 import moment from "moment";
 import { AnyString } from "@mikro-orm/core/typings";
 
-export const transformValue = (value: {
+const wrapIfNeeded=(data:string, wrap:boolean):string => {
+  return wrap?`'${data}'`:data;
+}
+
+export const transformValue = <U>(value: {
   type: keyof typeof types | AnyString;
-  value: unknown;
-}): unknown => {
+  value: U;
+}, wrapValue: boolean = false): U => {
   switch (value.type) {
     case "text":
     case "string":
-      return `'${value.value}'`;
+      return <U>wrapIfNeeded(`${value.value}`,wrapValue);
     case "datetime":
-      return `'${moment(value.value as Date).format("YYYY-MM-DDTHH:mm:ss.SSS")}'`;
+      return <U>wrapIfNeeded(`${moment(value.value as Date).format("YYYY-MM-DDTHH:mm:ss.SSS")}`,wrapValue);
     case "date":
-      return `'${moment(value.value as Date).format("YYYY-MM-DD")}'`;
+      return <U>wrapIfNeeded(`${moment(value.value as Date).format("YYYY-MM-DD")}`, wrapValue);
     case "time":
-      return `'${moment(value.value as Date).format("HH:mm:ss.SSS")}'`;
+      return <U>wrapIfNeeded(`${moment(value.value as Date).format("HH:mm:ss.SSS")}`,wrapValue);
     default:
       return value.value;
   }
 };
+
 export const parseDateTime = (value: string, format: string): Date => {
-  return moment(value, format).toDate();
+  const m = moment(value, format, true);
+  if (!m.isValid()) {
+    return moment(value).toDate();
+  }
+  return m.toDate();
 };