forge-sql-orm 1.0.31 → 2.0.0

package/src/core/ForgeSQLORM.ts

@@ -1,8 +1,3 @@
-import type { EntityName, LoggingOptions } from "..";
-import type { EntitySchema } from "@mikro-orm/core/metadata/EntitySchema";
-import type { AnyEntity, EntityClass, EntityClassGroup } from "@mikro-orm/core/typings";
-import type { QueryBuilder } from "@mikro-orm/knex/query";
-import { MemoryCacheAdapter, MikroORM, NullCacheAdapter } from "@mikro-orm/mysql";
 import { ForgeSQLCrudOperations } from "./ForgeSQLCrudOperations";
 import {
   CRUDForgeSQL,
@@ -11,52 +6,36 @@ import {
   SchemaSqlForgeSql,
 } from "./ForgeSQLQueryBuilder";
 import { ForgeSQLSelectOperations } from "./ForgeSQLSelectOperations";
-import type { Knex } from "knex";
+import { drizzle } from "drizzle-orm/mysql2";
+import { MySql2Database } from "drizzle-orm/mysql2/driver";
 
 /**
- * Implementation of ForgeSQLORM that interacts with MikroORM.
+ * Implementation of ForgeSQLORM that uses Drizzle ORM for query building.
+ * This class provides a bridge between Forge SQL and Drizzle ORM, allowing
+ * to use Drizzle's query builder while executing queries through Forge SQL.
  */
 class ForgeSQLORMImpl implements ForgeSqlOperation {
   private static instance: ForgeSQLORMImpl | null = null;
-  private readonly mikroORM: MikroORM;
+  private readonly drizzle: MySql2Database<Record<string, unknown>>;
   private readonly crudOperations: CRUDForgeSQL;
   private readonly fetchOperations: SchemaSqlForgeSql;
 
   /**
    * Private constructor to enforce singleton behavior.
-   * @param entities - The list of entities for ORM initialization.
    * @param options - Options for configuring ForgeSQL ORM behavior.
    */
-  private constructor(
-    entities: (EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[],
-    options?: ForgeSqlOrmOptions,
-  ) {
-
+  private constructor(options?: ForgeSqlOrmOptions) {
     try {
-      const newOptions: ForgeSqlOrmOptions = options ?? { logRawSqlQuery: false, disableOptimisticLocking: false };
-      if (newOptions.logRawSqlQuery){
+      const newOptions: ForgeSqlOrmOptions = options ?? {
+        logRawSqlQuery: false,
+        disableOptimisticLocking: false,
+      };
+      if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.mikroORM = MikroORM.initSync({
-        dbName: "inmemory",
-        schemaGenerator: {
-          disableForeignKeys: false,
-        },
-        discovery: {
-          warnWhenNoEntities: true,
-        },
-        resultCache: {
-          adapter: NullCacheAdapter,
-        },
-        metadataCache: {
-          enabled: false,
-          adapter: MemoryCacheAdapter,
-        },
-        entities: entities,
-        preferTs: false,
-        debug: false,
-      });
-
+      // Initialize Drizzle instance for query building only
+      // This instance should not be used for direct database connections
+      this.drizzle = drizzle("");
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -67,16 +46,12 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
 
   /**
    * Returns the singleton instance of ForgeSQLORMImpl.
-   * @param entities - List of entities (required only on first initialization).
    * @param options - Options for configuring ForgeSQL ORM behavior.
    * @returns The singleton instance of ForgeSQLORMImpl.
    */
-  static getInstance(
-    entities: (EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[],
-    options?: ForgeSqlOrmOptions,
-  ): ForgeSqlOperation {
+  static getInstance(options?: ForgeSqlOrmOptions): ForgeSqlOperation {
     if (!ForgeSQLORMImpl.instance) {
-      ForgeSQLORMImpl.instance = new ForgeSQLORMImpl(entities, options);
+      ForgeSQLORMImpl.instance = new ForgeSQLORMImpl(options);
     }
     return ForgeSQLORMImpl.instance;
   }
@@ -98,41 +73,28 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
   }
 
   /**
-   * Creates a new query builder for the given entity.
-   * @param entityName - The entity name or an existing query builder.
-   * @param alias - The alias for the entity.
-   * @param loggerContext - Logging options.
-   * @returns The query builder instance.
-   */
-  createQueryBuilder<Entity extends object, RootAlias extends string = never>(
-    entityName: EntityName<Entity> | QueryBuilder<Entity>,
-    alias?: RootAlias,
-    loggerContext?: LoggingOptions,
-  ): QueryBuilder<Entity, RootAlias> {
-    return this.mikroORM.em.createQueryBuilder(entityName, alias, undefined, loggerContext);
-  }
-
-  /**
-   * Provides access to the underlying Knex instance for building complex query parts.
-   * enabling advanced query customization and performance tuning.
-   * @returns The Knex instance, which can be used for query building.
+   * Returns a Drizzle query builder instance.
+   *
+   * ⚠️ IMPORTANT: This method should be used ONLY for query building purposes.
+   * The returned instance should NOT be used for direct database connections or query execution.
+   * All database operations should be performed through Forge SQL's executeRawSQL or executeRawUpdateSQL methods.
+   *
+   * @returns A Drizzle query builder instance for query construction only.
    */
-  getKnex(): Knex<any, any[]> {
-    return this.mikroORM.em.getKnex();
+  getDrizzleQueryBuilder(): MySql2Database<Record<string, unknown>> {
+    return this.drizzle;
   }
 }
 
 /**
  * Public class that acts as a wrapper around the private ForgeSQLORMImpl.
+ * Provides a clean interface for working with Forge SQL and Drizzle ORM.
  */
 class ForgeSQLORM {
   private readonly ormInstance: ForgeSqlOperation;
 
-  constructor(
-    entities: (EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[],
-    options?: ForgeSqlOrmOptions,
-  ) {
-    this.ormInstance = ForgeSQLORMImpl.getInstance(entities, options);
+  constructor(options?: ForgeSqlOrmOptions) {
+    this.ormInstance = ForgeSQLORMImpl.getInstance(options);
   }
 
   /**
@@ -151,20 +113,17 @@ class ForgeSQLORM {
     return this.ormInstance.fetch();
   }
 
-  getKnex(): Knex<any, any[]> {
-    return this.ormInstance.getKnex();
-  }
-
   /**
-   * Proxies the `createQueryBuilder` method from `ForgeSQLORMImpl`.
-   * @returns A new query builder instance.
+   * Returns a Drizzle query builder instance.
+   *
+   * ⚠️ IMPORTANT: This method should be used ONLY for query building purposes.
+   * The returned instance should NOT be used for direct database connections or query execution.
+   * All database operations should be performed through Forge SQL's executeRawSQL or executeRawUpdateSQL methods.
+   *
+   * @returns A Drizzle query builder instance for query construction only.
    */
-  createQueryBuilder<Entity extends object, RootAlias extends string = never>(
-    entityName: EntityName<Entity> | QueryBuilder<Entity>,
-    alias?: RootAlias,
-    loggerContext?: LoggingOptions,
-  ): QueryBuilder<Entity, RootAlias> {
-    return this.ormInstance.createQueryBuilder(entityName, alias, loggerContext);
+  getDrizzleQueryBuilder(): MySql2Database<Record<string, unknown>> {
+    return this.ormInstance.getDrizzleQueryBuilder();
   }
 }
 

package/src/core/ForgeSQLQueryBuilder.ts

@@ -1,197 +1,320 @@
 import { UpdateQueryResponse } from "@forge/sql";
-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, EntityProperty} from "@mikro-orm/core";
-import {SqlParameters} from "@forge/sql/out/sql-statement";
-import {DynamicEntity} from "./ComplexQuerySchemaBuilder";
+import { SqlParameters } from "@forge/sql/out/sql-statement";
+import { MySql2Database } from "drizzle-orm/mysql2/driver";
+import { AnyMySqlSelectQueryBuilder, AnyMySqlTable, customType } from "drizzle-orm/mysql-core";
+import { MySqlSelectDynamic } from "drizzle-orm/mysql-core/query-builders/select.types";
+import { InferInsertModel, SQL } from "drizzle-orm";
+import moment from "moment/moment";
+import { parseDateTime } from "../utils/sqlUtils";
+
+// ============= Core Types =============
 
 /**
  * Interface representing the main ForgeSQL operations.
+ * Provides access to CRUD operations and schema-level SQL operations.
  */
 export interface ForgeSqlOperation extends QueryBuilderForgeSql {
   /**
-   * Provides CRUD operations.
+   * Provides CRUD (Create, Read, Update, Delete) operations.
+   * @returns {CRUDForgeSQL} Interface for performing CRUD operations
    */
   crud(): CRUDForgeSQL;
 
   /**
    * Provides schema-level SQL fetch operations.
+   * @returns {SchemaSqlForgeSql} Interface for executing schema-bound SQL queries
    */
   fetch(): SchemaSqlForgeSql;
 }
 
 /**
- * Options for configuring ForgeSQL ORM behavior.
+ * Interface for Query Builder operations.
+ * Provides access to the underlying Drizzle ORM query builder.
  */
-export interface ForgeSqlOrmOptions {
-  /**
-   * Enables logging of raw SQL queries in the Atlassian Forge Developer Console.
-   */
-  logRawSqlQuery?: boolean;
+export interface QueryBuilderForgeSql {
   /**
-   * Disable optimistic locking
+   * Creates a new query builder for the given entity.
+   * @returns {MySql2Database<Record<string, unknown>>} The Drizzle database instance for building queries
    */
-  disableOptimisticLocking?: boolean
+  getDrizzleQueryBuilder(): MySql2Database<Record<string, unknown>>;
 }
 
+// ============= CRUD Operations =============
+
 /**
- * Interface for schema-level SQL operations.
+ * Interface for CRUD (Create, Read, Update, Delete) operations.
+ * Provides methods for basic database operations with support for optimistic locking.
  */
-export interface SchemaSqlForgeSql {
-  /**
-   * Executes a schema-bound SQL query and maps the 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.
-   */
-  executeSchemaSQL<T extends object>(query: string, schema: EntitySchema<T>): Promise<T[]>;
-
+export interface CRUDForgeSQL {
   /**
-   * 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.
+   * Inserts multiple records into the database.
+   * @template T - The type of the table schema
+   * @param {T} schema - The entity schema
+   * @param {Partial<InferInsertModel<T>>[]} models - The list of entities to insert
+   * @param {boolean} [updateIfExists] - Whether to update the row if it already exists (default: false)
+   * @returns {Promise<number>} The number of inserted rows
+   * @throws {Error} If the insert operation fails
    */
-  executeSchemaSQLOnlyOne<T extends object>(query: string, schema: EntitySchema<T>): Promise<T|undefined>;
+  insert<T extends AnyMySqlTable>(
+    schema: T,
+    models: Partial<InferInsertModel<T>>[],
+    updateIfExists?: boolean,
+  ): Promise<number>;
 
   /**
-   * Executes a raw SQL query and returns the results.
-   * @param query - The raw SQL query.
-   * @returns A list of results as objects.
+   * Deletes a record by its ID.
+   * @template T - The type of the table schema
+   * @param {unknown} id - The ID of the record to delete
+   * @param {T} schema - The entity schema
+   * @returns {Promise<number>} The number of rows affected
+   * @throws {Error} If the delete operation fails
    */
-  executeRawSQL<T extends object | unknown>(query: string): Promise<T[]>;
+  deleteById<T extends AnyMySqlTable>(id: unknown, schema: T): Promise<number>;
 
   /**
-   * Executes a raw SQL update query.
-   * @param query - The raw SQL update query.
-   * @param params - Sql parameters.
-   * @returns The update response containing affected rows.
+   * Updates a record by its ID with optimistic locking support.
+   * 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
+   *
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} entity - The entity with updated values
+   * @param {T} schema - The entity schema
+   * @returns {Promise<number>} The number of rows affected
+   * @throws {Error} If the primary key is not included in the update fields
+   * @throws {Error} If optimistic locking check fails
    */
-  executeRawUpdateSQL(query: string, params?: SqlParameters[]): Promise<UpdateQueryResponse>;
+  updateById<T extends AnyMySqlTable>(
+    entity: Partial<InferInsertModel<T>>,
+    schema: T,
+  ): Promise<number>;
 
   /**
-   * Creates a builder for constructing complex query schemas dynamically.
-   * This method is useful when working with dynamic entity structures where fields
-   * may not be known at compile time.
-   * @returns An instance of ComplexQuerySchemaBuilder configured for dynamic entities.
+   * 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.
+   *
+   * @template T - The type of the table schema
+   * @param {Partial<InferInsertModel<T>>} updateData - The object containing values to update
+   * @param {T} schema - The entity schema
+   * @param {SQL<unknown>} [where] - Optional filtering conditions for the WHERE clause
+   * @returns {Promise<number>} The number of affected rows
+   * @throws {Error} If no filtering criteria are provided
+   * @throws {Error} If the update operation fails
    */
-  createComplexQuerySchema():ComplexQuerySchemaBuilder<DynamicEntity>
+  updateFields<T extends AnyMySqlTable>(
+    updateData: Partial<InferInsertModel<T>>,
+    schema: T,
+    where?: SQL<unknown>,
+  ): Promise<number>;
 }
 
+// ============= Schema SQL Operations =============
+
 /**
- * Interface for CRUD (Create, Read, Update, Delete) operations.
+ * Interface for schema-level SQL operations.
+ * Provides methods for executing SQL queries with schema binding and type safety.
  */
-export interface CRUDForgeSQL {
+export interface SchemaSqlForgeSql {
   /**
-   * Inserts multiple records into the database.
-   * @param schema - The entity schema.
-   * @param models - The list of entities to insert.
-   * @param updateIfExists - Whether to update the row if it already exists.
-   * @returns The number of inserted rows.
+   * Executes a Drizzle query and returns the result.
+   * @template T - The type of the query builder
+   * @param {T} query - The Drizzle query to execute
+   * @returns {Promise<Awaited<T>>} The query result
+   * @throws {Error} If the query execution fails
    */
-  insert<T extends object>(
-    schema: EntitySchema<T>,
-    models: T[],
-    updateIfExists?: boolean,
-  ): Promise<number>;
+  executeQuery<T extends MySqlSelectDynamic<AnyMySqlSelectQueryBuilder>>(
+    query: T,
+  ): Promise<Awaited<T>>;
 
   /**
-   * Deletes a record by its ID.
-   * @param id - The ID of the record to delete.
-   * @param schema - The entity schema.
-   * @returns The number of rows affected.
+   * Executes a Drizzle query and returns a single result.
+   * @template T - The type of the query builder
+   * @param {T} query - The Drizzle query to execute
+   * @returns {Promise<Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined>} A single result object or undefined
+   * @throws {Error} If more than one record is returned
+   * @throws {Error} If the query execution fails
    */
-  deleteById<T extends object>(id: unknown, schema: EntitySchema<T>): Promise<number>;
+  executeQueryOnlyOne<T extends MySqlSelectDynamic<AnyMySqlSelectQueryBuilder>>(
+    query: T,
+  ): Promise<
+    Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined
+  >;
 
   /**
-   * 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).
+   * Executes a raw SQL query and returns the results.
+   * @template T - The type of the result objects
+   * @param {string} query - The raw SQL query
+   * @param {SqlParameters[]} [params] - Optional SQL parameters
+   * @returns {Promise<T[]>} A list of results as objects
+   * @throws {Error} If the query execution fails
    */
-   updateFields<T extends object>(
-      entity: Partial<T>,
-      fields: EntityKey<T>[],
-      schema: EntitySchema<T>,
-      where?: QBFilterQuery<T>,
-  ): Promise<number>
+  executeRawSQL<T extends object | unknown>(query: string, params?: SqlParameters[]): Promise<T[]>;
 
   /**
-   * 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.
+   * Executes a raw SQL update query.
+   * @param {string} query - The raw SQL update query
+   * @param {SqlParameters[]} [params] - Optional SQL parameters
+   * @returns {Promise<UpdateQueryResponse>} The update response containing affected rows
+   * @throws {Error} If the update operation fails
    */
-  updateFieldById<T extends object>(
-    entity: T,
-    fields: EntityKey<T>[],
-    schema: EntitySchema<T>,
-  ): Promise<void>;
+  executeRawUpdateSQL(query: string, params?: unknown[]): Promise<UpdateQueryResponse>;
 }
 
+// ============= Configuration Types =============
+
 /**
- * Interface for Query Builder operations.
+ * Interface for version field metadata.
+ * Defines the configuration for optimistic locking version fields.
  */
-export interface QueryBuilderForgeSql {
+export interface VersionFieldMetadata {
+  /** Name of the version field */
+  fieldName: string;
+}
+
+/**
+ * Interface for table metadata.
+ * Defines the configuration for a specific table.
+ */
+export interface TableMetadata {
+  /** Name of the table */
+  tableName: string;
+  /** Version field configuration for optimistic locking */
+  versionField: VersionFieldMetadata;
+}
+
+/**
+ * Type for additional metadata configuration.
+ * Maps table names to their metadata configuration.
+ */
+export type AdditionalMetadata = Record<string, TableMetadata>;
+
+/**
+ * Options for configuring ForgeSQL ORM behavior.
+ */
+export interface ForgeSqlOrmOptions {
   /**
-   * Creates a new query builder for the given entity.
-   * @param entityName - The entity name or an existing query builder.
-   * @param alias - The alias for the entity.
-   * @param loggerContext - Logging options.
-   * @returns The query builder instance.
+   * Enables logging of raw SQL queries in the Atlassian Forge Developer Console.
+   * Useful for debugging and monitoring SQL operations.
+   * @default false
    */
-  createQueryBuilder<Entity extends object, RootAlias extends string = never>(
-    entityName: EntityName<Entity> | QueryBuilder<Entity>,
-    alias?: RootAlias,
-    loggerContext?: LoggingOptions,
-  ): QueryBuilder<Entity, RootAlias>;
-
+  logRawSqlQuery?: boolean;
   /**
-   * Provides access to the underlying Knex instance for building complex query parts.
-   * enabling advanced query customization and performance tuning.
-   * @returns The Knex instance, which can be used for query building.
+   * Enables logging of raw SQL queries in the Atlassian Forge Developer Console.
+   * Useful for debugging and monitoring SQL operations.
+   * @default false
    */
-  getKnex(): Knex<any, any[]>;
-}
+  logRawSqlQueryParams?: boolean;
 
-export interface ComplexQuerySchemaBuilder<T> {
   /**
-   * Adds a field from an entity schema to the builder.
-   * @param field - The entity property to be added.
-   * @param alias - (Optional) Alias for the field name.
-   * @returns The updated instance of the builder.
+   * Disables optimistic locking for all operations.
+   * When enabled, version checks are skipped during updates.
+   * @default false
    */
-  addField<K>(field: Partial<EntityProperty<K>>, alias?: string): this
+  disableOptimisticLocking?: boolean;
 
   /**
-   * Creates and returns a new entity schema based on the added fields.
-   * @returns A new EntitySchema<T> instance.
+   * Additional metadata for table configuration.
+   * Allows specifying table-specific settings and behaviors.
+   * @example
+   * ```typescript
+   * {
+   *   users: {
+   *     tableName: "users",
+   *     versionField: {
+   *       fieldName: "updatedAt",
+   *       type: "datetime",
+   *       nullable: false
+   *     }
+   *   }
+   * }
+   * ```
    */
-  createSchema(): EntitySchema<T>;
+  additionalMetadata?: AdditionalMetadata;
 }
+
+// ============= Custom Types =============
+
+/**
+ * Custom type for MySQL datetime fields.
+ * Handles conversion between JavaScript Date objects and MySQL datetime strings.
+ */
+export const mySqlDateTimeString = customType<{
+  data: Date;
+  driver: string;
+  config: { format?: string };
+}>({
+  dataType() {
+    return "datetime";
+  },
+  toDriver(value: Date) {
+    return moment(value as Date).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value: unknown) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value as string, format);
+  },
+});
+
+/**
+ * Custom type for MySQL timestamp fields.
+ * Handles conversion between JavaScript Date objects and MySQL timestamp strings.
+ */
+export const mySqlTimestampString = customType<{
+  data: Date;
+  driver: string;
+  config: { format?: string };
+}>({
+  dataType() {
+    return "timestamp";
+  },
+  toDriver(value: Date) {
+    return moment(value as Date).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value: unknown) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value as string, format);
+  },
+});
+
+/**
+ * Custom type for MySQL date fields.
+ * Handles conversion between JavaScript Date objects and MySQL date strings.
+ */
+export const mySqlDateString = customType<{
+  data: Date;
+  driver: string;
+  config: { format?: string };
+}>({
+  dataType() {
+    return "date";
+  },
+  toDriver(value: Date) {
+    return moment(value as Date).format("YYYY-MM-DD");
+  },
+  fromDriver(value: unknown) {
+    const format = "YYYY-MM-DD";
+    return parseDateTime(value as string, format);
+  },
+});
+
+/**
+ * Custom type for MySQL time fields.
+ * Handles conversion between JavaScript Date objects and MySQL time strings.
+ */
+export const mySqlTimeString = customType<{
+  data: Date;
+  driver: string;
+  config: { format?: string };
+}>({
+  dataType() {
+    return "time";
+  },
+  toDriver(value: Date) {
+    return moment(value as Date).format("HH:mm:ss.SSS");
+  },
+  fromDriver(value: unknown) {
+    return parseDateTime(value as string, "HH:mm:ss.SSS");
+  },
+});