forge-sql-orm 2.1.23 → 2.1.24

package/src/core/ForgeSQLCrudOperations.ts

@@ -253,23 +253,15 @@ export class ForgeSQLCrudOperations implements VerioningModificationForgeSQL {
   }
 
   /**
-   * Validates and retrieves version field metadata.
-   * @param {string} tableName - The name of the table
-   * @param {Record<string, AnyColumn>} columns - The table columns
-   * @returns {Object | undefined} Version field metadata if valid, undefined otherwise
+   * Finds version field in columns by name.
    */
-  private validateVersionField(
-    tableName: string,
+  private findVersionField(
+    versionMetadata: { fieldName: string },
     columns: Record<string, AnyColumn>,
-  ): { fieldName: string; type: string } | undefined {
-    if (this.options.disableOptimisticLocking) {
-      return undefined;
-    }
-    const versionMetadata = this.options.additionalMetadata?.[tableName]?.versionField;
-    if (!versionMetadata) return undefined;
+  ): { fieldName: string; field: AnyColumn } | null {
     let fieldName = versionMetadata.fieldName;
-
     let versionField = columns[versionMetadata.fieldName];
+
     if (!versionField) {
       const find = Object.entries(columns).find(([, c]) => c.name === versionMetadata.fieldName);
       if (find) {
@@ -277,29 +269,38 @@ export class ForgeSQLCrudOperations implements VerioningModificationForgeSQL {
         versionField = find[1];
       }
     }
-    if (!versionField) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `Version field "${versionMetadata.fieldName}" not found in table ${tableName}. Versioning will be skipped.`,
-      );
-      return undefined;
-    }
 
+    return versionField ? { fieldName, field: versionField } : null;
+  }
+
+  /**
+   * Validates that version field is not nullable.
+   */
+  private validateVersionFieldNotNull(
+    versionMetadata: { fieldName: string },
+    versionField: AnyColumn,
+    tableName: string,
+  ): boolean {
     if (!versionField.notNull) {
       // eslint-disable-next-line no-console
       console.warn(
         `Version field "${versionMetadata.fieldName}" in table ${tableName} is nullable. Versioning may not work correctly.`,
       );
-      return undefined;
+      return false;
     }
+    return true;
+  }
 
-    const fieldType = versionField.getSQLType();
-    const isSupportedType =
-      fieldType === "datetime" ||
-      fieldType === "timestamp" ||
-      fieldType === "int" ||
-      fieldType === "number" ||
-      fieldType === "decimal";
+  /**
+   * Validates that version field type is supported.
+   */
+  private validateVersionFieldType(
+    versionMetadata: { fieldName: string },
+    fieldType: string,
+    tableName: string,
+  ): boolean {
+    const supportedTypes = ["datetime", "timestamp", "int", "number", "decimal"];
+    const isSupportedType = supportedTypes.includes(fieldType);
 
     if (!isSupportedType) {
       // eslint-disable-next-line no-console
@@ -307,10 +308,50 @@ export class ForgeSQLCrudOperations implements VerioningModificationForgeSQL {
         `Version field "${versionMetadata.fieldName}" in table ${tableName} has unsupported type "${fieldType}". ` +
           `Only datetime, timestamp, int, and decimal types are supported for versioning. Versioning will be skipped.`,
       );
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Validates and retrieves version field metadata.
+   * @param {string} tableName - The name of the table
+   * @param {Record<string, AnyColumn>} columns - The table columns
+   * @returns {Object | undefined} Version field metadata if valid, undefined otherwise
+   */
+  private validateVersionField(
+    tableName: string,
+    columns: Record<string, AnyColumn>,
+  ): { fieldName: string; type: string } | undefined {
+    // Early exit conditions
+    if (this.options.disableOptimisticLocking) {
+      return undefined;
+    }
+    const versionMetadata = this.options.additionalMetadata?.[tableName]?.versionField;
+    if (!versionMetadata) {
       return undefined;
     }
 
-    return { fieldName, type: fieldType };
+    // Find and validate version field
+    const found = this.findVersionField(versionMetadata, columns);
+    if (!found) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `Version field "${versionMetadata.fieldName}" not found in table ${tableName}. Versioning will be skipped.`,
+      );
+      return undefined;
+    }
+
+    // Validate field properties
+    const isValid =
+      this.validateVersionFieldNotNull(versionMetadata, found.field, tableName) &&
+      this.validateVersionFieldType(versionMetadata, found.field.getSQLType(), tableName);
+
+    if (!isValid) {
+      return undefined;
+    }
+
+    return { fieldName: found.fieldName, type: found.field.getSQLType() };
   }
 
   /**
@@ -376,12 +417,23 @@ export class ForgeSQLCrudOperations implements VerioningModificationForgeSQL {
 
     const modelWithVersion = { ...model };
     const fieldType = versionField.getSQLType();
-    const versionValue = fieldType === "datetime" || fieldType === "timestamp" ? new Date() : 1;
+    const dateTimeTypes = ["datetime", "timestamp"];
+    const versionValue = dateTimeTypes.includes(fieldType) ? new Date() : 1;
     modelWithVersion[fieldName as keyof typeof modelWithVersion] = versionValue as any;
 
     return modelWithVersion as InferInsertModel<T>;
   }
 
+  /**
+   * Calculates new version value based on field type.
+   */
+  private calculateNewVersionValue(fieldType: string, currentVersion: unknown): any {
+    const dateTimeTypes = ["datetime", "timestamp"];
+    return dateTimeTypes.includes(fieldType)
+      ? new Date()
+      : (((currentVersion as number) + 1) as any);
+  }
+
   /**
    * Prepares update data with version field.
    * @template T - The type of the table schema
@@ -404,9 +456,7 @@ export class ForgeSQLCrudOperations implements VerioningModificationForgeSQL {
       if (versionField) {
         const fieldType = versionField.getSQLType();
         updateData[versionMetadata.fieldName as keyof typeof updateData] =
-          fieldType === "datetime" || fieldType === "timestamp"
-            ? new Date()
-            : (((currentVersion as number) + 1) as any);
+          this.calculateNewVersionValue(fieldType, currentVersion);
       }
     }
 

package/src/core/ForgeSQLQueryBuilder.ts

@@ -54,6 +54,28 @@ import {
   SelectResultField,
 } from "drizzle-orm/query-builders/select.types";
 import { SQLWrapper } from "drizzle-orm/sql/sql";
+
+/**
+ * Type alias for MySqlSelectBase return type used in selectFrom methods.
+ * Reduces code duplication in type definitions.
+ */
+export type SelectFromReturnType<T extends MySqlTable> = MySqlSelectBase<
+  GetSelectTableName<T>,
+  GetSelectTableSelection<T>,
+  "single",
+  MySqlRemotePreparedQueryHKT,
+  GetSelectTableName<T> extends string ? Record<string & GetSelectTableName<T>, "not-null"> : {},
+  false,
+  never,
+  {
+    [K in keyof {
+      [Key in keyof GetSelectTableSelection<T>]: SelectResultField<GetSelectTableSelection<T>[Key]>;
+    }]: {
+      [Key in keyof GetSelectTableSelection<T>]: SelectResultField<GetSelectTableSelection<T>[Key]>;
+    }[K];
+  }[],
+  any
+>;
 import type { MySqlQueryResultKind } from "drizzle-orm/mysql-core/session";
 import type { WithBuilder } from "drizzle-orm/mysql-core/subquery";
 import { WithSubquery } from "drizzle-orm/subquery";
@@ -216,29 +238,7 @@ export interface QueryBuilderForgeSql {
    * const users = await forgeSQL.selectFrom(userTable).where(eq(userTable.id, 1));
    * ```
    */
-  selectFrom<T extends MySqlTable>(
-    table: T,
-  ): MySqlSelectBase<
-    GetSelectTableName<T>,
-    GetSelectTableSelection<T>,
-    "single",
-    MySqlRemotePreparedQueryHKT,
-    GetSelectTableName<T> extends string ? Record<string & GetSelectTableName<T>, "not-null"> : {},
-    false,
-    never,
-    {
-      [K in keyof {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }]: {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }[K];
-    }[],
-    any
-  >;
+  selectFrom<T extends MySqlTable>(table: T): SelectFromReturnType<T>;
 
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -271,29 +271,7 @@ export interface QueryBuilderForgeSql {
    * const uniqueUsers = await forgeSQL.selectDistinctFrom(userTable).where(eq(userTable.status, 'active'));
    * ```
    */
-  selectDistinctFrom<T extends MySqlTable>(
-    table: T,
-  ): MySqlSelectBase<
-    GetSelectTableName<T>,
-    GetSelectTableSelection<T>,
-    "single",
-    MySqlRemotePreparedQueryHKT,
-    GetSelectTableName<T> extends string ? Record<string & GetSelectTableName<T>, "not-null"> : {},
-    false,
-    never,
-    {
-      [K in keyof {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }]: {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }[K];
-    }[],
-    any
-  >;
+  selectDistinctFrom<T extends MySqlTable>(table: T): SelectFromReturnType<T>;
 
   /**
    * Creates a cacheable select query with unique field aliases to prevent field name collisions in joins.
@@ -330,30 +308,7 @@ export interface QueryBuilderForgeSql {
    * const users = await forgeSQL.selectCacheableFrom(userTable, 300).where(eq(userTable.id, 1));
    * ```
    */
-  selectCacheableFrom<T extends MySqlTable>(
-    table: T,
-    cacheTTL?: number,
-  ): MySqlSelectBase<
-    GetSelectTableName<T>,
-    GetSelectTableSelection<T>,
-    "single",
-    MySqlRemotePreparedQueryHKT,
-    GetSelectTableName<T> extends string ? Record<string & GetSelectTableName<T>, "not-null"> : {},
-    false,
-    never,
-    {
-      [K in keyof {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }]: {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }[K];
-    }[],
-    any
-  >;
+  selectCacheableFrom<T extends MySqlTable>(table: T, cacheTTL?: number): SelectFromReturnType<T>;
 
   /**
    * Creates a cacheable distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -393,27 +348,7 @@ export interface QueryBuilderForgeSql {
   selectDistinctCacheableFrom<T extends MySqlTable>(
     table: T,
     cacheTTL?: number,
-  ): MySqlSelectBase<
-    GetSelectTableName<T>,
-    GetSelectTableSelection<T>,
-    "single",
-    MySqlRemotePreparedQueryHKT,
-    GetSelectTableName<T> extends string ? Record<string & GetSelectTableName<T>, "not-null"> : {},
-    false,
-    never,
-    {
-      [K in keyof {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }]: {
-        [Key in keyof GetSelectTableSelection<T>]: SelectResultField<
-          GetSelectTableSelection<T>[Key]
-        >;
-      }[K];
-    }[],
-    any
-  >;
+  ): SelectFromReturnType<T>;
 
   /**
    * Creates an insert query builder.
@@ -1344,28 +1279,38 @@ export interface ForgeSqlOrmOptions {
   additionalMetadata?: AdditionalMetadata;
 }
 
+/**
+ * Creates a custom type for date/time fields with specified format and timestamp validation.
+ */
+function createDateCustomType(dataType: string, format: string, isTimeStamp: boolean) {
+  return customType<{
+    data: Date;
+    driver: string;
+    config: { format?: string };
+  }>({
+    dataType() {
+      return dataType;
+    },
+    toDriver(value: Date) {
+      return formatDateTime(value, format, isTimeStamp);
+    },
+    fromDriver(value: unknown) {
+      return parseDateTime(value as string, format);
+    },
+  });
+}
+
 /**
  * Custom type for MySQL datetime fields.
  * Handles conversion between JavaScript Date objects and MySQL datetime strings.
  *
  * @type {CustomType}
  */
-export const forgeDateTimeString = customType<{
-  data: Date;
-  driver: string;
-  config: { format?: string };
-}>({
-  dataType() {
-    return "datetime";
-  },
-  toDriver(value: Date) {
-    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", false);
-  },
-  fromDriver(value: unknown) {
-    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
-    return parseDateTime(value as string, format);
-  },
-});
+export const forgeDateTimeString = createDateCustomType(
+  "datetime",
+  "yyyy-MM-dd' 'HH:mm:ss.SSS",
+  false,
+);
 
 /**
  * Custom type for MySQL timestamp fields.
@@ -1373,22 +1318,11 @@ export const forgeDateTimeString = customType<{
  *
  * @type {CustomType}
  */
-export const forgeTimestampString = customType<{
-  data: Date;
-  driver: string;
-  config: { format?: string };
-}>({
-  dataType() {
-    return "timestamp";
-  },
-  toDriver(value: Date) {
-    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", true);
-  },
-  fromDriver(value: unknown) {
-    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
-    return parseDateTime(value as string, format);
-  },
-});
+export const forgeTimestampString = createDateCustomType(
+  "timestamp",
+  "yyyy-MM-dd' 'HH:mm:ss.SSS",
+  true,
+);
 
 /**
  * Custom type for MySQL date fields.
@@ -1396,22 +1330,7 @@ export const forgeTimestampString = customType<{
  *
  * @type {CustomType}
  */
-export const forgeDateString = customType<{
-  data: Date;
-  driver: string;
-  config: { format?: string };
-}>({
-  dataType() {
-    return "date";
-  },
-  toDriver(value: Date) {
-    return formatDateTime(value, "yyyy-MM-dd", false);
-  },
-  fromDriver(value: unknown) {
-    const format = "yyyy-MM-dd";
-    return parseDateTime(value as string, format);
-  },
-});
+export const forgeDateString = createDateCustomType("date", "yyyy-MM-dd", false);
 
 /**
  * Custom type for MySQL time fields.
@@ -1419,18 +1338,4 @@ export const forgeDateString = customType<{
  *
  * @type {CustomType}
  */
-export const forgeTimeString = customType<{
-  data: Date;
-  driver: string;
-  config: { format?: string };
-}>({
-  dataType() {
-    return "time";
-  },
-  toDriver(value: Date) {
-    return formatDateTime(value, "HH:mm:ss.SSS", false);
-  },
-  fromDriver(value: unknown) {
-    return parseDateTime(value as string, "HH:mm:ss.SSS");
-  },
-});
+export const forgeTimeString = createDateCustomType("time", "HH:mm:ss.SSS", false);