fix(json-api-nestjs-typeorm): Fix mysql like error

Mysql do not support ilike, use for it like

fixes: #104

Author: klerick

.env

@@ -1,19 +1,17 @@
 DB_HOST=localhost
 DB_LOGGING=1
+DB_NAME="json-api-db"
 
 DB_USERNAME="postgres"
 DB_PASSWORD="postgres"
-#DB_NAME="json-api-db"
-DB_NAME="postgres"
 DB_PORT=5432
 DB_TYPE=postgres
 
 #DB_USERNAME="root"
-#DB_PASSWORD="password"
-#DB_NAME="example_new"
+#DB_PASSWORD="mysql"
 #DB_PORT=3306
 #DB_TYPE=mysql
 
 
-ORM_TYPE=microorm
-#ORM_TYPE=typeorm
+#ORM_TYPE=microorm
+ORM_TYPE=typeorm

apps/json-api-server-e2e/src/json-api/json-api-sdk/get-method.spec.ts

@@ -32,7 +32,7 @@ describe('GET method:', () => {
   beforeAll(async () => {
     jsonSdk = creatSdk();
 
-    const addressesPromise = Array.from(new Array(2)).map(() => {
+    const addressesPromise = Array.from(new Array(5)).map(() => {
       const address = new Addresses();
       address.city = faker.string.alpha(50);
       address.state = faker.string.alpha(50);
@@ -61,7 +61,7 @@ describe('GET method:', () => {
       const addressIndex = index % 2 === 0 ? 0 : 1;
       const user = getUser();
       user.isActive = !!addressIndex;
-      user.addresses = addressArray[addressIndex];
+      user.addresses = addressArray[index];
       return jsonSdk.jonApiSdkService.postOne(user);
     });
     usersArray = await Promise.all(usersPromise);
@@ -148,6 +148,16 @@ describe('GET method:', () => {
       users2.forEach((user) => {
         expect(user.isActive).toBe(false);
       });
+
+      const resultFindLike = await jsonSdk.jonApiSdkService.getAll(Users, {
+        filter: {
+          target: {
+            login: { [FilterOperand.like]: users2.at(0)?.login.slice(5, -5) },
+          },
+        },
+      });
+      expect(resultFindLike.length).toBe(1);
+      expect(resultFindLike.at(0)?.id).toBe(users2.at(0)?.id);
     });
 
     it('Should be get entities with filter by relation target', async () => {

docker-compose.yaml

@@ -1,11 +1,5 @@
 version: '3.8'
 services:
-#  api-gate:
-#    container_name: api-gate
-#    restart: always
-#    build: apps/api-gate/
-#    ports:
-#      - "3000:3000"
   postgres:
     image: postgres:15.1-alpine
     restart: always
@@ -29,23 +23,20 @@ services:
       - pgadmin:/root/.pgadmin
     ports:
       - '8000:80'
-#  redis:
-#    image: redis:6.2-alpine
-#    restart: always
-#    ports:
-#      - '6379:6379'
-#    command: redis-server --save 20 1 --loglevel warning
-#    volumes:
-#      - redis:/data
-#  jaeger:
-#    image: jaegertracing/all-in-one:1.41
-#    ports:
-#      - "16686:16686"
-#      - "14268:14268"
+  db:
+    image: mysql:latest
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: mysql
+    ports:
+      - '3306:3306'
+    volumes:
+      - mysql-db:/var/lib/mysql
+
 volumes:
   db:
     driver: local
-#  redis:
-#    driver: local
+  mysql-db:
+    driver: local
   pgadmin:
     driver: local

libs/json-api/json-api-nestjs-typeorm/src/lib/service/typeorm-utils.service.spec.ts

@@ -363,9 +363,15 @@ describe('TypeormUtilsService', () => {
           throw new Error(`name is not pattern: params_${alias}_\\d{1,}`);
         }
         const expressionMap = expression.replace(name, EXPRESSION);
-        const checkFilterOperand = Object.entries(FilterOperand).find(
+
+        const checkFilterOperand = Object.entries({
+          ...FilterOperand,
+          like: 'ilike',
+        } as any).find(
+          // @ts-ignore
           ([key, val]) => OperandsMapExpression[val] === expressionMap
         );
+
         if (!checkFilterOperand) {
           expect(checkFilterOperand).not.toBe(undefined);
           throw new Error(`expression incorrect`);
@@ -580,7 +586,7 @@ describe('TypeormUtilsService', () => {
         throw Error('Should be like pattern');
       }
 
-      expect(second.expression).toBe(`ILIKE :${secondResult[0]}`);
+      expect(second.expression).toBe(`LIKE :${secondResult[0]}`);
       expect(second.alias).toBe('Users__Comments_comments.createdAt');
       expect(second.selectInclude).toBe('comments');
       if (!Array.isArray(second.params)) {

libs/json-api/json-api-nestjs-typeorm/src/lib/service/typeorm-utils.service.ts

@@ -5,7 +5,14 @@ import {
   NotFoundException,
   UnprocessableEntityException,
 } from '@nestjs/common';
-import { EntityMetadata, Equal, In, Repository } from 'typeorm';
+import {
+  EntityMetadata,
+  Equal,
+  In,
+  Repository,
+  ILike,
+  FindOperator,
+} from 'typeorm';
 import { RelationMetadata as TypeOrmRelationMetadata } from 'typeorm/metadata/RelationMetadata';
 import {
   ObjectTyped,
@@ -31,6 +38,7 @@ import {
 } from '../type';
 
 import { CURRENT_ENTITY_REPOSITORY } from '../constants';
+import { DriverUtils } from 'typeorm/driver/DriverUtils';
 
 type RelationAlias<E> = {
   [K in UnionToTuple<RelationKeys<E>>[number] & PropertyKey]: string;
@@ -255,9 +263,18 @@ export class TypeormUtilsService<
     for (const [fieldName, filter] of ObjectTyped.entries(filterTarget)) {
       if (!filter) continue;
       for (const entries of ObjectTyped.entries(filter)) {
-        const [operand, value] = entries as [FilterOperand, string];
+        const [operandFromQuery, value] = entries as [FilterOperand, string];
         const valueConditional =
-          operand === FilterOperand.like ? `%${value}%` : value;
+          operandFromQuery === FilterOperand.like ? `%${value}%` : value;
+
+        const operand = DriverUtils.isPostgresFamily(
+          this.repository.manager.connection.driver
+        )
+          ? operandFromQuery === FilterOperand.like
+            ? 'ilike'
+            : operandFromQuery
+          : operandFromQuery;
+
         const fieldWithAlias = this.getAliasPath(fieldName);
         const paramsName = this.getParamName(fieldWithAlias);
 

libs/json-api/json-api-nestjs-typeorm/src/lib/type.ts

@@ -17,11 +17,12 @@ export const OperandsMapExpression = {
   [FilterOperand.gt]: `> :${EXPRESSION}`,
   [FilterOperand.gte]: `>= :${EXPRESSION}`,
   [FilterOperand.in]: `IN (:...${EXPRESSION})`,
-  [FilterOperand.like]: `ILIKE :${EXPRESSION}`,
+  [FilterOperand.like]: `LIKE :${EXPRESSION}`,
   [FilterOperand.lt]: `< :${EXPRESSION}`,
   [FilterOperand.lte]: `<= :${EXPRESSION}`,
   [FilterOperand.nin]: `NOT IN (:...${EXPRESSION})`,
   [FilterOperand.some]: `&& :${EXPRESSION}`,
+  ilike: `ILIKE :${EXPRESSION}`,
 };
 
 export const OperandMapExpressionForNull = {

libs/typeorm-database/src/lib/config-cli.ts

@@ -2,7 +2,7 @@ import { DataSource, DataSourceOptions } from 'typeorm';
 import { join } from 'path';
 import * as process from 'process';
 
-const config: DataSourceOptions = {
+const configPg: DataSourceOptions = {
   type: process.env['DB_TYPE'] as 'mysql' | 'postgres',
   host: process.env['DB_HOST'],
   port: parseInt(`${process.env['DB_PORT']}`, 10),
@@ -15,23 +15,25 @@ const config: DataSourceOptions = {
   ...(process.env['DB_TYPE'] === 'mysql' ? { connectorPackage: 'mysql2' } : {}),
 };
 
-// const config: DataSourceOptions = {
-//   type: 'mysql',
-//   host: 'localhost',
-//   username: 'root',
-//   connectorPackage: 'mysql2',
-//   password: 'password',
-//   database: 'example_new',
-//   logging: true,
-//   migrations: [join(__dirname, '/migrations/**/*{.ts,.js}')],
-//   entities: [join(__dirname, '/entities/**/*{.ts,.js}')],
-// };
+const configMysql: DataSourceOptions = {
+  type: process.env['DB_TYPE'] as 'mysql' | 'postgres',
+  host: process.env['DB_HOST'],
+  port: parseInt(`${process.env['DB_PORT']}`, 10),
+  username: process.env['DB_USERNAME'],
+  password: process.env['DB_PASSWORD'],
+  database: process.env['DB_NAME'],
+  logging: process.env['DB_LOGGING'] === '1',
+  migrations: [join(__dirname, '/migrations-mysql/**/*{.ts,.js}')],
+  entities: [join(__dirname, '/entities-mysql/**/*{.ts,.js}')],
+  connectorPackage: 'mysql2',
+};
 
 const configSeeder = {
   seeders: ['./libs/database/src/lib/seeders/*.ts'],
   defaultSeeder: 'RootSeeder',
 };
 
+const config = process.env['DB_TYPE'] === 'mysql' ? configMysql : configPg;
 export { config, configSeeder };
 
 export default new DataSource({ ...config, ...configSeeder });

libs/typeorm-database/src/lib/entities-mysql/addresses.ts

@@ -0,0 +1,58 @@
+import {
+  PrimaryGeneratedColumn,
+  OneToOne,
+  Column,
+  Entity,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { Users, IUsers } from '.';
+
+export type IAddresses = Addresses;
+
+@Entity('addresses')
+export class Addresses {
+  @PrimaryGeneratedColumn()
+  public id!: number;
+
+  @Column({
+    type: 'varchar',
+    length: 70,
+    nullable: true,
+    default: 'NULL',
+  })
+  public city!: string;
+
+  @Column({
+    type: 'varchar',
+    length: 70,
+    nullable: true,
+    default: 'NULL',
+  })
+  public state!: string;
+
+  @Column({
+    type: 'varchar',
+    length: 68,
+    nullable: true,
+    default: 'NULL',
+  })
+  public country!: string;
+
+  @Column({
+    name: 'created_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public createdAt!: Date;
+
+  @UpdateDateColumn({
+    name: 'updated_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public updatedAt!: Date;
+
+  @OneToOne(() => Users, (item) => item.addresses)
+  public user!: IUsers;
+}

libs/typeorm-database/src/lib/entities-mysql/book-list.ts

@@ -0,0 +1,40 @@
+import {
+  Column,
+  Entity,
+  ManyToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { IUsers, Users } from './users';
+
+export type IBookList = BookList;
+
+@Entity('book_list')
+export class BookList {
+  @PrimaryGeneratedColumn()
+  public id!: string;
+
+  @Column({
+    type: 'text',
+    nullable: false,
+  })
+  public text!: string;
+
+  @Column({
+    name: 'created_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public createdAt!: Date;
+
+  @UpdateDateColumn({
+    name: 'updated_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public updatedAt!: Date;
+
+  @ManyToMany(() => Users, (item) => item.books)
+  public users!: IUsers[];
+}

libs/typeorm-database/src/lib/entities-mysql/comments.ts

@@ -0,0 +1,57 @@
+import {
+  PrimaryGeneratedColumn,
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  UpdateDateColumn,
+} from 'typeorm';
+
+export enum CommentKind {
+  Comment = 'COMMENT',
+  Message = 'MESSAGE',
+  Note = 'NOTE',
+}
+
+import { Users, IUsers } from '.';
+
+export type IComments = Comments;
+
+@Entity('comments')
+export class Comments {
+  @PrimaryGeneratedColumn()
+  public id!: number;
+
+  @Column({
+    type: 'text',
+    nullable: false,
+  })
+  public text!: string;
+
+  @Column({
+    type: 'enum',
+    enum: CommentKind,
+    nullable: false,
+  })
+  public kind!: CommentKind;
+
+  @Column({
+    name: 'created_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public createdAt!: Date;
+
+  @UpdateDateColumn({
+    name: 'updated_at',
+    type: 'timestamp',
+    nullable: true,
+  })
+  public updatedAt!: Date;
+
+  @ManyToOne(() => Users, (item: Users) => item.id)
+  @JoinColumn({
+    name: 'created_by',
+  })
+  public createdBy!: IUsers;
+}