pg-mvc-service 1.0.16 → 1.0.18

package/dist/models/SqlUtils/ValidateValueUtil.js

@@ -117,6 +117,12 @@ class ValidateValueUtil {
                     throw new Error('Please enter a value of type bool, or a string "true" or "false", or a number 0 or 1.');
                 }
                 break;
+            case "json":
+            case "jsonb":
+                if (this.isErrorJson(value)) {
+                    throw new Error('Please enter a value as an Object or JSON string.');
+                }
+                break;
         }
     }
     static isErrorValue(columnType, value) {
@@ -149,6 +155,10 @@ class ValidateValueUtil {
                     case "bool[]":
                         isError = this.isErrorBool(v);
                         break;
+                    case "json[]":
+                    case "jsonb[]":
+                        isError = this.isErrorJson(v);
+                        break;
                     default:
                         throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
                 }
@@ -173,6 +183,9 @@ class ValidateValueUtil {
                 return this.isErrorNumber(value);
             case "bool":
                 return this.isErrorBool(value);
+            case "json":
+            case "jsonb":
+                return this.isErrorJson(value);
             default:
                 throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
         }
@@ -246,5 +259,20 @@ class ValidateValueUtil {
         }
         return true;
     }
+    static isErrorJson(value) {
+        if (typeof value === 'object' && value !== null && Array.isArray(value) === false) {
+            return false;
+        }
+        if (typeof value === 'string') {
+            try {
+                JSON.parse(value);
+                return false;
+            }
+            catch (_a) {
+                return true;
+            }
+        }
+        return true;
+    }
 }
 exports.default = ValidateValueUtil;

package/dist/models/SqlUtils/WhereExpression.js

@@ -76,7 +76,11 @@ class WhereExpression {
             time: ["=", "!=", ">", ">=", "<", "<="],
             'time[]': [],
             timestamp: ["=", "!=", ">", ">=", "<", "<="],
-            'timestamp[]': []
+            'timestamp[]': [],
+            json: [],
+            'json[]': [],
+            jsonb: [],
+            'jsonb[]': []
         };
         if (useableOperator[leftColumn.type].includes(operator) == false) {
             throw new Error(`The ${operator} operator cannot be used for ${leftColumn.tableName}.${leftColumn.columnName}. (${leftColumn.type})`);

package/dist/models/TableDoc.js

@@ -331,11 +331,17 @@ function toColumnType(column) {
     else if (column.type.startsWith('string')) {
         return column.type.replace('string', `VARCHAR(${column.length})`);
     }
+    else if (column.type.startsWith('timestamp')) {
+        return column.type.replace('timestamp', 'TIMESTAMP');
+    }
     else if (column.type.startsWith('time')) {
         return column.type.replace('time', 'TIME');
     }
-    else if (column.type.startsWith('timestamp')) {
-        return column.type.replace('timestamp', 'TIMESTAMP');
+    else if (column.type.startsWith('jsonb')) {
+        return column.type.replace('jsonb', 'JSONB');
+    }
+    else if (column.type.startsWith('json')) {
+        return column.type.replace('json', 'JSON');
     }
     return '';
 }

package/dist/models/TableModel.js

@@ -123,6 +123,10 @@ class TableModel {
             'time[]': '{name} should be entered as an array of times in "hh:mi" format or "hh:mi:ss" format.',
             'timestamp': '{name} should be entered in "YYYY-MM-DD" format, "YYYY-MM-DD hh:mi:ss" format, "YYYY-MM-DDThh:mi:ss" format, or as a Date type.',
             'timestamp[]': '{name} should be entered as an array of timestamps in "YYYY-MM-DD" format, "YYYY-MM-DD hh:mi:ss" format, "YYYY-MM-DDThh:mi:ss" format, or as Date types.',
+            'json': '{name} should be entered as an Object or JSON string.',
+            'json[]': '{name} should be entered as an array of Objects or JSON strings.',
+            'jsonb': '{name} should be entered as an Object or JSON string.',
+            'jsonb[]': '{name} should be entered as an array of Objects or JSON strings.',
             'length': '{name} should be entered within {length} characters.',
             'null': '{name} is not allowed to be null.',
             'notInput': 'Please enter {name}.',
@@ -144,6 +148,10 @@ class TableModel {
             'time[]': '{name}は"hh:mi"形式または"hh:mi:ss"形式の配列で入力してください。',
             'timestamp': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、"YYYY-MM-DDThh:mi:ss"形式、またはDate型で入力してください。',
             'timestamp[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、"YYYY-MM-DDThh:mi:ss"形式、またはDate型の配列で入力してください。',
+            'json': '{name}はObject形またはJSON文字列で入力してください。',
+            'json[]': '{name}はObject形またはJSON文字列の配列で入力してください。',
+            'jsonb': '{name}はObject形またはJSON文字列で入力してください。',
+            'jsonb[]': '{name}はObject形またはJSON文字列の配列で入力してください。',
             'length': '{name}は{length}文字以内で入力してください。',
             'null': '{name}はnullを許可されていません。',
             'notInput': '{name}を入力してください。',

package/dist/models/ValidateClient.js

@@ -35,10 +35,10 @@ class ValidateClient {
             return false;
         }
     }
-    validateInList(option, key, list, error) {
+    validateInList(options, key, list, error) {
         var _a, _b;
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -54,10 +54,10 @@ class ValidateClient {
             throw new Exception_1.UnprocessableException(code, message);
         }
     }
-    validateUnderNow(option, key, error) {
+    validateUnderNow(options, key, error) {
         var _a, _b;
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -77,10 +77,10 @@ class ValidateClient {
             throw new Exception_1.UnprocessableException(code, message);
         }
     }
-    validateUnderToday(option, key, isErrorToday, error) {
+    validateUnderToday(options, key, isErrorToday, error) {
         var _a, _b;
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -113,10 +113,10 @@ class ValidateClient {
             throw new Exception_1.UnprocessableException(code, message);
         }
     }
-    validateRegExp(option, key, regExp, error) {
+    validateRegExp(options, key, regExp, error) {
         var _a, _b;
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -137,10 +137,10 @@ class ValidateClient {
             throw new Exception_1.UnprocessableException(code, message);
         }
     }
-    validatePositiveNumber(option, key, error) {
+    validatePositiveNumber(options, key, error) {
         var _a, _b;
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }

package/index.d.ts

@@ -3,19 +3,24 @@ import { Request, Response } from 'express';
 import { Pool, PoolClient } from 'pg';
 import { ErrorMessageType, IncomingHttpHeaders } from './src/reqestResponse/RequestType';
 import { ArrayType, EnumType, ObjectType, PrimitiveType } from './src/reqestResponse/ReqResType';
-import { AwsS3Client } from './src/clients/AwsS3Client';
+
+import { MethodType } from './src/Service';
+export { MethodType } from './src/Service';
+
 import { Base64Client } from './src/clients/Base64Client';
 import { StringClient } from './src/clients/StringClient';
 import { EncryptClient } from './src/clients/EncryptClient';
 
+import { AwsS3Client } from './src/clients/AwsS3Client';
 export { AwsS3Client } from './src/clients/AwsS3Client';
 
 // models class
 import ValidateClient from './src/models/ValidateClient';
 
-declare module 'pg-mvc-service' {
-    export type MethodType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+import { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
+export { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
 
+declare module 'pg-mvc-service' {
     export class Service {
         protected readonly method: MethodType;
         get Method(): MethodType;
@@ -67,7 +72,7 @@ declare module 'pg-mvc-service' {
         get EncryptClient(): EncryptClient;
 
         public requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
-            method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>>;
+            method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>>;
     }
 
     export interface IParams {
@@ -138,59 +143,6 @@ declare module 'pg-mvc-service' {
         constructor(errorId: string, message?: string);
     }
 
-    export type TSqlValue = string | number | boolean | Date | null | Array<string | null> | Array<number | null> | Array<Date | null> | Array<Boolean | null>;
-
-    // column type
-    export type TColumnAttribute = "primary" | "nullable" | "hasDefault" | "noDefault";
-    export type TColumnType = "number" | "string" | "uuid" |  "date" | "time" | "timestamp" | "bool";
-    export type TColumnArrayType = "number[]" | "string[]" | "uuid[]" |  "date[]" | "time[]" | "timestamp[]" | "bool[]";
-    type TColumnBase = {
-        alias?: string,
-        type: TColumnType | TColumnArrayType,
-        attribute: TColumnAttribute,
-        default?: string,
-        comment?: string
-    };
-    
-    type TStringColumn = TColumnBase & {
-        type: "string",
-        length: number
-    };
-    
-    type TNonStringColumn = TColumnBase & {
-        type: Exclude<TColumnType, "string">,
-        length?: undefined
-    };
-    
-    type TStringArrayColumn = TColumnBase & {
-        type: "string[]",
-        length: number,
-        attribute: Exclude<TColumnAttribute, "primary">
-    };
-    
-    type TArrayColumn = TColumnBase & {
-        type:  Exclude<TColumnArrayType, "string[]">,
-        length?: undefined,
-        attribute: Exclude<TColumnAttribute, "primary">
-    };
-    
-    export type TColumn = TStringColumn | TNonStringColumn | TStringArrayColumn | TArrayColumn;
-    
-    export type TOperator = "=" | "!=" | ">" | ">=" | "<" | "<=" | "like" | "ilike" | "h2f_like" | "h2f_ilike" | "in" | "not in";
-    export type TColumnInfo = { model: TableModel, name: string }
-    export type TQuery = {sql: string, vars?: Array<any>};
-    export type TSelectExpression = { expression: string, alias: string }
-    export type TAggregateFuncType = 'sum' | 'avg' | 'max' | 'min' | 'count';
-    export type TCondition = string | {
-        l: string | TColumnInfo, 
-        o: TOperator, 
-        r: TSqlValue | Array<TSqlValue> | TColumnInfo
-    };
-    export type TNestedCondition = TCondition | ['AND' | 'OR', ...TNestedCondition[]] | TNestedCondition[];
-    export type TSortKeyword = 'desc' | 'asc';
-    export type TKeyFormat = 'snake' | 'lowerCamel';
-    export type TOption = {[key: string]: TSqlValue};
-
     export class TableModel {
         protected readonly dbName: string;
         get DbName(): string;
@@ -229,8 +181,8 @@ declare module 'pg-mvc-service' {
 
         public where(expression: string): void;
         public where(conditions: Array<TNestedCondition>): void;
-        public where(left: string, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
-        public where(left: TColumnInfo, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
+        public where(left: string, operator: TOperator, right: any | TColumnInfo): void;
+        public where(left: TColumnInfo, operator: TOperator, right: any | TColumnInfo): void;
 
         public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null, keyFormat: TKeyFormat): Promise<T | null>;
         public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
@@ -244,16 +196,16 @@ declare module 'pg-mvc-service' {
 
         protected readonly errorMessages: Record<TColumnType | 'length' | 'null' | 'notInput', string>
         protected throwValidationError(code: string, message: string): never;
-        protected validateOptions(options: TOption, isInsert: boolean) : Promise<void>;
-        protected validateInsert(options: TOption) : Promise<void>;
-        protected validateUpdate(options: TOption) : Promise<void>;
-        protected validateUpdateId(id: any, options: TOption) : Promise<void>;
+        protected validateOptions(options: {[key: string]: any}, isInsert: boolean) : Promise<void>;
+        protected validateInsert(options: {[key: string]: any}) : Promise<void>;
+        protected validateUpdate(options: {[key: string]: any}) : Promise<void>;
+        protected validateUpdateId(id: any, options: {[key: string]: any}) : Promise<void>;
         protected validateDelete() : Promise<void>;
         protected validateDeleteId(id: any) : Promise<void>;
 
-        public executeInsert(options: TOption) : Promise<void>;
-        public executeUpdate(options: TOption) : Promise<number>;
-        public executeUpdateId(id: any, options: TOption) : Promise<void>;
+        public executeInsert(options: {[key: string]: any}) : Promise<void>;
+        public executeUpdate(options: {[key: string]: any}) : Promise<number>;
+        public executeUpdateId(id: any, options: {[key: string]: any}) : Promise<void>;
         public executeDelete() : Promise<number>;
         public executeDeleteId(id: any) : Promise<void>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-mvc-service",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "",
   "homepage": "https://github.com/n-daira/npm-pack_mvc-service#readme",
   "bugs": {

package/src/Service.ts

@@ -218,7 +218,7 @@ export class Service {
     }
 
     public async requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
-        method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>> {
+        method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>> {
 
         // GET,DELETEのparamをURLクエリに
         if (method === 'GET' || method === 'DELETE') {

package/src/models/SqlUtils/ValidateValueUtil.ts

@@ -127,6 +127,12 @@ export default class ValidateValueUtil {
                     throw new Error('Please enter a value of type bool, or a string "true" or "false", or a number 0 or 1.');
                 }
                 break;
+            case "json":
+            case "jsonb":
+                if (this.isErrorJson(value)) {
+                    throw new Error('Please enter a value as an Object or JSON string.');
+                }
+                break;
         }
     }
 
@@ -162,6 +168,10 @@ export default class ValidateValueUtil {
                     case "bool[]":
                         isError = this.isErrorBool(v);
                         break;
+                    case "json[]":
+                    case "jsonb[]":
+                        isError = this.isErrorJson(v);
+                        break;
                     default:
                         throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
                 }
@@ -189,6 +199,9 @@ export default class ValidateValueUtil {
                 return this.isErrorNumber(value);
             case "bool":
                 return this.isErrorBool(value);
+            case "json":
+            case "jsonb":
+                return this.isErrorJson(value);
             default:
                 throw new Error(`The specified ColumnTypeEnum does not exist. (${columnType})`);
         }
@@ -267,4 +280,21 @@ export default class ValidateValueUtil {
 
         return true;
     }
+
+    static isErrorJson(value: any): boolean {
+        if (typeof value === 'object' && value !== null && Array.isArray(value) === false) {
+            return false;
+        }
+
+        if (typeof value === 'string') {
+            try {
+                JSON.parse(value);
+                return false;
+            } catch {
+                return true;
+            }
+        }
+
+        return true;
+    }
 }

package/src/models/SqlUtils/WhereExpression.ts

@@ -1,5 +1,5 @@
 import { TableModel } from "../TableModel";
-import { TColumnArrayType, TColumnDetail, TColumnInfo, TColumnType, TNestedCondition, TOperator, TQuery, TSqlValue } from "../Type";
+import { TColumnArrayType, TColumnDetail, TColumnInfo, TColumnType, TNestedCondition, TOperator, TQuery } from "../Type";
 import ValidateValueUtil from "./ValidateValueUtil";
 
 export default class WhereExpression {
@@ -66,7 +66,7 @@ export default class WhereExpression {
         }
     }
 
-    public static create(left: TColumnInfo, operator: TOperator, right: TSqlValue | null | Array<TSqlValue> | TColumnInfo, varLength: number) : TQuery {
+    public static create(left: TColumnInfo, operator: TOperator, right: TColumnInfo | any, varLength: number) : TQuery {
 
         // Check if the specified ColumnInfo exists
         const leftColumn = left.model.getColumn(left.name);
@@ -86,7 +86,11 @@ export default class WhereExpression {
             time: ["=", "!=", ">", ">=", "<", "<="],
             'time[]': [],
             timestamp: ["=", "!=", ">", ">=", "<", "<="],
-            'timestamp[]': []
+            'timestamp[]': [],
+            json: [],
+            'json[]': [],
+            jsonb: [],
+            'jsonb[]': []
         };
 
         if (useableOperator[leftColumn.type].includes(operator) == false) {
@@ -118,7 +122,7 @@ export default class WhereExpression {
         }
     }
 
-    private static createExpression(leftColumn: TColumnDetail, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo, varLength: number) : TQuery {
+    private static createExpression(leftColumn: TColumnDetail, operator: TOperator, right: TColumnInfo | any, varLength: number) : TQuery {
         // IN NOT IN clause
         if (["in", "not in"].includes(operator)) {
             if (Array.isArray(right) == false) {
@@ -192,7 +196,7 @@ export default class WhereExpression {
         }
     }
 
-    private static createExpressionArrayValue(leftColumn: TColumnDetail, operator: TOperator, right: TSqlValue | Array<TSqlValue>, varLength: number) : TQuery {
+    private static createExpressionArrayValue(leftColumn: TColumnDetail, operator: TOperator, right: any, varLength: number) : TQuery {
 
         // ValidateValueUtil.validateValue(leftColumn, right);
         // LIKE operators are different, so handle separately

package/src/models/TableDoc.ts

@@ -337,10 +337,14 @@ function toColumnType(column: TColumn) {
         return column.type.replace('number', 'INTEGER');
     } else if (column.type.startsWith('string')) {
         return column.type.replace('string', `VARCHAR(${column.length})`);
-    } else if (column.type.startsWith('time')) {
-        return column.type.replace('time', 'TIME');
     } else if (column.type.startsWith('timestamp')) {
         return column.type.replace('timestamp', 'TIMESTAMP');
+    } else if (column.type.startsWith('time')) {
+        return column.type.replace('time', 'TIME');
+    } else if (column.type.startsWith('jsonb')) {
+        return column.type.replace('jsonb', 'JSONB');
+    } else if (column.type.startsWith('json')) {
+        return column.type.replace('json', 'JSON');
     }
 
     return '';

package/src/models/TableModel.ts

@@ -1,5 +1,5 @@
 import { Pool, PoolClient } from 'pg';
-import { TAggregateFuncType, TColumn, TColumnArrayType, TColumnAttribute, TColumnDetail, TColumnInfo, TColumnType, TKeyFormat, TNestedCondition, TOperator, TOption, TQuery, TSelectExpression, TSortKeyword, TSqlValue } from "./Type";
+import { TAggregateFuncType, TColumn, TColumnArrayType, TColumnDetail, TColumnInfo, TColumnType, TKeyFormat, TNestedCondition, TOperator, TQuery, TSelectExpression, TSortKeyword } from "./Type";
 import ValidateValueUtil from './SqlUtils/ValidateValueUtil';
 import SelectExpression from './SqlUtils/SelectExpression';
 import WhereExpression from './SqlUtils/WhereExpression';
@@ -277,9 +277,9 @@ export class TableModel {
 
     public where(expression: string): void;
     public where(conditions: Array<TNestedCondition>): void;
-    public where(left: string, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
-    public where(left: TColumnInfo, operator: TOperator, right: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void;
-    public where(left: string | TColumnInfo | Array<TNestedCondition>, operator?: TOperator, right?: TSqlValue | Array<TSqlValue> | TColumnInfo | null): void {
+    public where(left: string, operator: TOperator, right: TColumnInfo | any): void;
+    public where(left: TColumnInfo, operator: TOperator, right: TColumnInfo | any): void;
+    public where(left: string | TColumnInfo | Array<TNestedCondition>, operator?: TOperator, right?: TColumnInfo | any): void {
         if (typeof left === 'string') {
             if (operator === undefined || right === undefined) {
                 this.whereExpressions.push(left);
@@ -416,6 +416,10 @@ export class TableModel {
         'time[]': '{name} should be entered as an array of times in "hh:mi" format or "hh:mi:ss" format.',
         'timestamp': '{name} should be entered in "YYYY-MM-DD" format, "YYYY-MM-DD hh:mi:ss" format, "YYYY-MM-DDThh:mi:ss" format, or as a Date type.',
         'timestamp[]': '{name} should be entered as an array of timestamps in "YYYY-MM-DD" format, "YYYY-MM-DD hh:mi:ss" format, "YYYY-MM-DDThh:mi:ss" format, or as Date types.',
+        'json': '{name} should be entered as an Object or JSON string.',
+        'json[]': '{name} should be entered as an array of Objects or JSON strings.',
+        'jsonb': '{name} should be entered as an Object or JSON string.',
+        'jsonb[]': '{name} should be entered as an array of Objects or JSON strings.',
         'length': '{name} should be entered within {length} characters.',
         'null': '{name} is not allowed to be null.',
         'notInput': 'Please enter {name}.',
@@ -437,6 +441,10 @@ export class TableModel {
         'time[]': '{name}は"hh:mi"形式または"hh:mi:ss"形式の配列で入力してください。',
         'timestamp': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、"YYYY-MM-DDThh:mi:ss"形式、またはDate型で入力してください。',
         'timestamp[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、"YYYY-MM-DDThh:mi:ss"形式、またはDate型の配列で入力してください。',
+        'json': '{name}はObject形またはJSON文字列で入力してください。',
+        'json[]': '{name}はObject形またはJSON文字列の配列で入力してください。',
+        'jsonb': '{name}はObject形またはJSON文字列で入力してください。',
+        'jsonb[]': '{name}はObject形またはJSON文字列の配列で入力してください。',
         'length': '{name}は{length}文字以内で入力してください。',
         'null': '{name}はnullを許可されていません。',
         'notInput': '{name}を入力してください。',
@@ -444,7 +452,7 @@ export class TableModel {
         'idNotExist': '指定されたID({id})はテーブルに存在しません。',
     }
 
-    private throwException(code: string, type: TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist', columnName: string, vallue: TSqlValue): never {
+    private throwException(code: string, type: TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist', columnName: string, vallue: any): never {
         const column = this.getColumn(columnName);
         
         let message = this.errorMessages[type];
@@ -461,7 +469,7 @@ export class TableModel {
     protected readonly errorMessages: Record<TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist', string> = 
         process.env.TZ === 'Asia/Tokyo' ? this.errorMessageJapan : this.errorMessageEnglish;
 
-    protected async validateOptions(options: TOption, isInsert: boolean): Promise<void> {
+    protected async validateOptions(options: {[key: string]: any}, isInsert: boolean): Promise<void> {
         if (Object.keys(options).length === 0) {
             throw new Error('At least one key-value pair is required in options.');
         }
@@ -531,7 +539,7 @@ export class TableModel {
         }
     }
 
-    protected async validateInsert(options: TOption) : Promise<void> {
+    protected async validateInsert(options: {[key: string]: any}) : Promise<void> {
         for (const key in this.Columns) {
             const column = this.getColumn(key);
             const name = (column.alias === undefined || column.alias === '') ? key : column.alias;
@@ -544,12 +552,12 @@ export class TableModel {
         }
     }
 
-    protected async validateUpdate(options: TOption) : Promise<void> { }
-    protected async validateUpdateId(id: any, options: TOption) : Promise<void> { }
+    protected async validateUpdate(options: {[key: string]: any}) : Promise<void> { }
+    protected async validateUpdateId(id: any, options: {[key: string]: any}) : Promise<void> { }
     protected async validateDelete() : Promise<void> { }
     protected async validateDeleteId(id: any) : Promise<void> { }
 
-    public async executeInsert(options: TOption) : Promise<void> {
+    public async executeInsert(options: {[key: string]: any}) : Promise<void> {
         await this.validateOptions(options, true);
         await this.validateInsert(options);
 
@@ -570,7 +578,7 @@ export class TableModel {
         await this.executeQuery(sql, vars);
     }
 
-    public async executeUpdate(options: TOption) : Promise<number> {
+    public async executeUpdate(options: {[key: string]: any}) : Promise<number> {
         await this.validateOptions(options, false);
         await this.validateUpdate(options);
 
@@ -606,7 +614,7 @@ export class TableModel {
         return data.rowCount;
     }
 
-    public async executeUpdateId(id: any, options: TOption) : Promise<void> {
+    public async executeUpdateId(id: any, options: {[key: string]: any}) : Promise<void> {
         ValidateValueUtil.validateId(this.Columns, id);
         await this.validateOptions(options, false);
         await this.validateUpdateId(id, options);

package/src/models/Type.ts

@@ -1,11 +1,9 @@
-import { TableModel } from "./TableModel";
-
-export type TSqlValue = string | number | boolean | Date | null | Array<string | null> | Array<number | null> | Array<Date | null> | Array<Boolean | null>;
+import type { TableModel } from "./TableModel";
 
 // column type
 export type TColumnAttribute = "primary" | "nullable" | "hasDefault" | "noDefault";
-export type TColumnType = "number" | "string" | "uuid" |  "date" | "time" | "timestamp" | "bool";
-export type TColumnArrayType = "number[]" | "string[]" | "uuid[]" |  "date[]" | "time[]" | "timestamp[]" | "bool[]";
+export type TColumnType = "number" | "string" | "uuid" |  "date" | "time" | "timestamp" | "bool" | "json" | "jsonb";
+export type TColumnArrayType = "number[]" | "string[]" | "uuid[]" |  "date[]" | "time[]" | "timestamp[]" | "bool[]" | "json[]" | "jsonb[]";
 type TColumnBase = {
     alias?: string,
     type: TColumnType | TColumnArrayType,
@@ -16,12 +14,18 @@ type TColumnBase = {
 
 type TStringColumn = TColumnBase & {
     type: "string",
-    length: number
+    length: number,
 };
 
-type TNonStringColumn = TColumnBase & {
+type TJsonColumn = TColumnBase & {
+    type: "json" | "jsonb"
+    length?: undefined,
+    attribute: Exclude<TColumnAttribute, "primary">
+};
+
+type TBasicColumn = TColumnBase & {
     type: Exclude<TColumnType, "string">,
-    length?: undefined
+    length?: undefined,
 };
 
 type TStringArrayColumn = TColumnBase & {
@@ -36,7 +40,7 @@ type TArrayColumn = TColumnBase & {
     attribute: Exclude<TColumnAttribute, "primary">
 };
 
-export type TColumn = TStringColumn | TNonStringColumn | TStringArrayColumn | TArrayColumn;
+export type TColumn = TStringColumn | TJsonColumn | TBasicColumn | TStringArrayColumn | TArrayColumn;
 export type TColumnDetail = TColumn & {
     columnName: string,
     tableName: string,
@@ -51,9 +55,8 @@ export type TAggregateFuncType = 'sum' | 'avg' | 'max' | 'min' | 'count';
 export type TCondition = string | {
     l: string | TColumnInfo, 
     o: TOperator, 
-    r: TSqlValue | Array<TSqlValue> | TColumnInfo
+    r: any | TColumnInfo
 };
 export type TNestedCondition = TCondition | ['AND' | 'OR', ...TNestedCondition[]] | TNestedCondition[];
 export type TSortKeyword = 'desc' | 'asc';
-export type TKeyFormat = 'snake' | 'lowerCamel';
-export type TOption = {[key: string]: TSqlValue};
+export type TKeyFormat = 'snake' | 'lowerCamel';

package/src/models/ValidateClient.ts

@@ -1,7 +1,6 @@
 import { UnprocessableException } from "../exceptions/Exception";
 import ValidateValueUtil from "./SqlUtils/ValidateValueUtil";
 import { TableModel } from "./TableModel";
-import { TOption, TSqlValue } from "./Type";
 
 type TError = {code?: string; message?: string;};
 
@@ -44,9 +43,9 @@ export default class ValidateClient {
         }
     }
 
-    public validateInList(option: TOption, key: string, list: Array<TSqlValue>, error?: TError) {
+    public validateInList(options: {[key: string]: any}, key: string, list: Array<number | string | boolean>, error?: TError) {
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -64,9 +63,9 @@ export default class ValidateClient {
         }
     }
 
-    public validateUnderNow(option: TOption, key: string, error?: TError) {
+    public validateUnderNow(options: {[key: string]: any}, key: string, error?: TError) {
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -89,9 +88,9 @@ export default class ValidateClient {
         }
     }
 
-    public validateUnderToday(option: TOption, key: string, isErrorToday: boolean, error?: TError): void {
+    public validateUnderToday(options: {[key: string]: any}, key: string, isErrorToday: boolean, error?: TError): void {
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -128,9 +127,9 @@ export default class ValidateClient {
         }
     }
 
-    public validateRegExp(option: TOption, key: string, regExp: RegExp | string, error?: TError): void {
+    public validateRegExp(options: {[key: string]: any}, key: string, regExp: RegExp | string, error?: TError): void {
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }
@@ -155,9 +154,9 @@ export default class ValidateClient {
         }
     }
 
-    public validatePositiveNumber(option: TOption, key: string, error?: TError) {
+    public validatePositiveNumber(options: {[key: string]: any}, key: string, error?: TError) {
         const column = this.model.getColumn(key);
-        const value = option[key];
+        const value = options[key];
         if (value === undefined || value === null || value === "") {
             return;
         }