pg-mvc-service 1.0.28 → 2.0.1

package/dist/models/TableModel.js

@@ -20,6 +20,7 @@ const ValidateClient_1 = __importDefault(require("./ValidateClient"));
 const Exception_1 = require("../exceptions/Exception");
 const ExpressionClient_1 = __importDefault(require("./ExpressionClient"));
 const UpdateExpression_1 = __importDefault(require("./SqlUtils/UpdateExpression"));
+const MessageUtil_1 = __importDefault(require("./Utils/MessageUtil"));
 class TableModel {
     get DbName() { return this.dbName; }
     get TableName() {
@@ -59,7 +60,12 @@ class TableModel {
     get createSqlFromJoinWhere() {
         let sql = ` FROM ${this.TableName} as "${this.TableAlias}"`;
         for (const join of this.joinConditions) {
-            sql += join.type === 'left' ? ' LEFT OUTER JOIN' : ' INNER JOIN';
+            const joins = {
+                inner: ' INNER JOIN',
+                left: ' LEFT OUTER JOIN',
+                full: ' FULL OUTER JOIN',
+            };
+            sql += joins[join.type];
             sql += ` ${join.model.TableName} as "${join.model.TableAlias}" ON `;
             const query = WhereExpression_1.default.createCondition(join.conditions, this, this.vars.length + 1);
             sql += query.expression;
@@ -113,71 +119,14 @@ class TableModel {
         this.groupExpression = [];
         this.sortExpression = [];
         this.vars = [];
-        this.errorMessageEnglish = {
-            'string': '{name} should be entered as a string or number type.',
-            'string[]': '{name} should be entered as an array of string or number types.',
-            'uuid': '{name} should be entered as a UUID.',
-            'uuid[]': '{name} should be entered as an array of UUIDs.',
-            'integer': '{name} should be entered as a number.',
-            'integer[]': '{name} should be entered as an array of numbers.',
-            'real': '{name} should be entered as a number.',
-            'real[]': '{name} should be entered as an array of numbers.',
-            'bool': '{name} should be entered as a bool type, "true", "false", 0, or 1.',
-            'bool[]': '{name} should be entered as an array of bool types, "true", "false", 0, or 1.',
-            'date': '{name} should be entered in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.',
-            'date[]': '{name} should be entered as an array of dates in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as Date types.',
-            'time': '{name} should be entered in "hh:mi" format or "hh:mi:ss" format.',
-            '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}.',
-            'fk': 'The value of {name} does not exist in the table.',
-            'idNotExist': 'The specified ID({id}) does not exist in the table.',
-            'find': 'The specified data does not exist in the table. ({pks})'
-        };
-        this.errorMessageJapan = {
-            'string': '{name}はstringかnumberで入力してください。',
-            'string[]': '{name}はstringかnumberの配列で入力してください。',
-            'uuid': '{name}はuuidで入力してください。',
-            'uuid[]': '{name}はuuidの配列で入力してください。',
-            'integer': '{name}はnumberか半角数字のstring型で入力してください。',
-            'integer[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
-            'real': '{name}はnumberか半角数字のstring型で入力してください。',
-            'real[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
-            'bool': '{name}はbool型、"true"、"false"、0、または1で入力してください。',
-            'bool[]': '{name}はbool型、"true"、"false"、0、または1の配列で入力してください。',
-            'date': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型で入力してください。',
-            'date[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型の配列で入力してください。',
-            'time': '{name}は"hh:mi"形式または"hh:mi:ss"形式で入力してください。',
-            '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}を入力してください。',
-            'fk': '{name}の値がテーブルに存在しません。',
-            'idNotExist': '指定されたID({id})はテーブルに存在しません。',
-            'find': '指定されたデータはテーブルに存在しません。({pks})'
-        };
-        this.errorMessages = process.env.TZ === 'Asia/Tokyo' ? this.errorMessageJapan : this.errorMessageEnglish;
+        this.errorMessages = process.env.TZ === 'Asia/Tokyo' ? MessageUtil_1.default.optionErrorMessageJapan : MessageUtil_1.default.optionErrorMessageEnglish;
         this.client = client;
         if (tableAlias !== undefined && tableAlias.trim() !== '') {
             this.tableAlias = tableAlias;
         }
     }
-    findId(id_1) {
-        return __awaiter(this, arguments, void 0, function* (id, selectColumns = "*", selectExpressions = null, keyFormat = 'snake') {
-            ValidateValueUtil_1.default.validateId(this.Columns, id);
+    find(pkOrId_1) {
+        return __awaiter(this, arguments, void 0, function* (pkOrId, selectColumns = "*", selectExpressions = null, keyFormat = 'snake') {
             let selects = [];
             if (selectColumns == "*") {
                 for (const key of Object.keys(this.Columns)) {
@@ -194,32 +143,16 @@ class TableModel {
                     selects.push(`${expression.expression} as "${expression.alias}"`);
                 }
             }
-            const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE id = $1`;
-            let datas = yield this.executeQuery(sql, [id]);
-            return datas.rowCount == 0 ? null : datas.rows[0];
-        });
-    }
-    find(pk_1) {
-        return __awaiter(this, arguments, void 0, function* (pk, selectColumns = "*", selectExpressions = null, keyFormat = 'snake') {
-            let selects = [];
-            if (selectColumns == "*") {
-                for (const key of Object.keys(this.Columns)) {
-                    selects.push(SelectExpression_1.default.create({ model: this, name: key }, null, null, keyFormat));
-                }
+            let query;
+            if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+                ValidateValueUtil_1.default.validateId(this.Columns, pkOrId);
+                query = WhereExpression_1.default.createConditionPk(this, { id: pkOrId });
             }
-            else if (selectColumns != null) {
-                for (const key of selectColumns) {
-                    selects.push(SelectExpression_1.default.create({ model: this, name: key }, null, null, keyFormat));
-                }
-            }
-            if (selectExpressions != null) {
-                for (const expression of selectExpressions) {
-                    selects.push(`${expression.expression} as "${expression.alias}"`);
-                }
+            else {
+                query = WhereExpression_1.default.createConditionPk(this, pkOrId);
             }
-            const { expression, vars } = WhereExpression_1.default.createConditionPk(this, pk);
-            const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE ${expression}`;
-            let datas = yield this.executeQuery(sql, vars);
+            const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE ${query.expression}`;
+            let datas = yield this.executeQuery(sql, query.vars);
             return datas.rowCount == 0 ? null : datas.rows[0];
         });
     }
@@ -395,7 +328,7 @@ class TableModel {
             return { datas: data.rows, count: Number(countData.rows[0].count), lastPage: Math.ceil(Number(countData.rows[0].count) / this.PageCount) };
         });
     }
-    throwException(code, type, columnName, vallue) {
+    throwException(code, type, columnName, value) {
         var _a;
         const column = this.getColumn(columnName);
         let message = this.errorMessages[type];
@@ -447,6 +380,16 @@ class TableModel {
             }
             // 外部キー制約チェック
             if (isInsert) {
+                for (const key in this.Columns) {
+                    const column = this.getColumn(key);
+                    const name = (column.alias === undefined || column.alias === '') ? key : column.alias;
+                    if (options[key] === undefined || options[key] === null) {
+                        // Null許容されていないカラムにNULLを入れようとしているか？
+                        if (column.attribute === "primary" || column.attribute === "noDefault") {
+                            this.throwException("005", "notInput", key, options[key]);
+                        }
+                    }
+                }
                 for (const ref of this.References) {
                     const refValues = ref.columns.map(col => options[col.target]);
                     // 全ての値がnullの場合はスキップ
@@ -456,49 +399,22 @@ class TableModel {
                     // 一部の値がnullの場合はエラー
                     if (refValues.some(value => value === null || value === undefined)) {
                         const name = ref.columns.map(col => { var _a; return (_a = this.getColumn(col.target).alias) !== null && _a !== void 0 ? _a : this.getColumn(col.target).columnName; }).join(',');
-                        throw new Exception_1.UnprocessableException("005", this.errorMessages.null.replace('{name}', name));
+                        throw new Exception_1.UnprocessableException("006", this.errorMessages.null.replace('{name}', name));
                     }
                     let refIndex = 1;
                     const sql = `SELECT COUNT(*) as count FROM ${ref.table} WHERE ${ref.columns.map(col => `${col.ref} = $${refIndex++}`).join(" AND ")}`;
                     const datas = yield this.clientQuery(sql, refValues);
                     if (datas.rows[0].count == "0") {
                         const name = ref.columns.map(col => { var _a; return (_a = this.getColumn(col.target).alias) !== null && _a !== void 0 ? _a : this.getColumn(col.target).columnName; }).join(',');
-                        throw new Exception_1.DbConflictException("006", this.errorMessages.fk.replace('{name}', name));
+                        throw new Exception_1.DbConflictException("007", this.errorMessages.fk.replace('{name}', name));
                     }
                 }
             }
         });
     }
-    validateInsert(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const key in this.Columns) {
-                const column = this.getColumn(key);
-                const name = (column.alias === undefined || column.alias === '') ? key : column.alias;
-                if (options[key] === undefined || options[key] === null) {
-                    // Null許容されていないカラムにNULLを入れようとしているか？
-                    if (column.attribute === "primary" || column.attribute === "noDefault") {
-                        this.throwException("101", "notInput", key, options[key]);
-                    }
-                }
-            }
-        });
-    }
-    validateUpdate(options) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    validateUpdateId(id, options) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    validateDelete() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    validateDeleteId(id) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    executeInsert(options) {
+    insert(options) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.validateOptions(options, true);
-            yield this.validateInsert(options);
             const columns = [];
             const vars = [];
             for (const [key, value] of Object.entries(options)) {
@@ -513,10 +429,47 @@ class TableModel {
             yield this.executeQuery(sql, vars);
         });
     }
+    update(pkOrId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.validateOptions(options, false);
+            const updateSetQuery = UpdateExpression_1.default.createUpdateSet(this, options);
+            let whereQuery;
+            if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+                ValidateValueUtil_1.default.validateId(this.Columns, pkOrId);
+                whereQuery = WhereExpression_1.default.createConditionPk(this, { id: pkOrId }, updateSetQuery.vars);
+            }
+            else {
+                whereQuery = WhereExpression_1.default.createConditionPk(this, pkOrId, updateSetQuery.vars);
+            }
+            const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
+            const data = yield this.executeQuery(sql, whereQuery.vars);
+            if (data.rowCount !== 1) {
+                throw new Exception_1.UnprocessableException("201", this.errorMessages.find.replace('{pks}', ((_a = whereQuery.vars) !== null && _a !== void 0 ? _a : []).join(',')));
+            }
+        });
+    }
+    delete(pkOrId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let whereQuery;
+            if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+                ValidateValueUtil_1.default.validateId(this.Columns, pkOrId);
+                whereQuery = WhereExpression_1.default.createConditionPk(this, { id: pkOrId });
+            }
+            else {
+                whereQuery = WhereExpression_1.default.createConditionPk(this, pkOrId);
+            }
+            const sql = `DELETE FROM ${this.TableName} WHERE ${whereQuery.expression}`;
+            const data = yield this.executeQuery(sql, whereQuery.vars);
+            if (data.rowCount !== 1) {
+                throw new Exception_1.UnprocessableException("301", this.errorMessages.find.replace('{pks}', ((_a = whereQuery.vars) !== null && _a !== void 0 ? _a : []).join(',')));
+            }
+        });
+    }
     executeUpdate(options) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.validateOptions(options, false);
-            yield this.validateUpdate(options);
             const updateExpressions = [];
             for (const [key, value] of Object.entries(options)) {
                 const column = this.getColumn(key);
@@ -544,40 +497,8 @@ class TableModel {
             return data.rowCount;
         });
     }
-    executeUpdateId(id, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            ValidateValueUtil_1.default.validateId(this.Columns, id);
-            yield this.validateOptions(options, false);
-            yield this.validateUpdateId(id, options);
-            yield this.validateUpdate(options);
-            const updateSetQuery = UpdateExpression_1.default.createUpdateSet(this, options);
-            const whereQuery = WhereExpression_1.default.createConditionPk(this, { id: id }, updateSetQuery.vars);
-            const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
-            const data = yield this.executeQuery(sql, whereQuery.vars);
-            if (data.rowCount !== 1) {
-                throw new Exception_1.UnprocessableException("201", this.errorMessages.find.replace('{pks}', ((_a = whereQuery.vars) !== null && _a !== void 0 ? _a : []).join(',')));
-            }
-        });
-    }
-    executeUpdateByPk(pk, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield this.validateOptions(options, false);
-            // await this.validateUpdateId(id, options);
-            yield this.validateUpdate(options);
-            const updateSetQuery = UpdateExpression_1.default.createUpdateSet(this, options);
-            const whereQuery = WhereExpression_1.default.createConditionPk(this, pk, updateSetQuery.vars);
-            const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
-            const data = yield this.executeQuery(sql, whereQuery.vars);
-            if (data.rowCount !== 1) {
-                throw new Exception_1.UnprocessableException("401", this.errorMessages.find.replace('{pks}', ((_a = whereQuery.vars) !== null && _a !== void 0 ? _a : []).join(',')));
-            }
-        });
-    }
     executeDelete() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.validateDelete();
             let sql = `DELETE FROM ${this.TableName} "${this.TableAlias}" `;
             if (this.joinConditions.length > 0) {
                 const tables = [];
@@ -598,17 +519,6 @@ class TableModel {
             return datas.rowCount;
         });
     }
-    executeDeleteId(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            ValidateValueUtil_1.default.validateId(this.Columns, id);
-            yield this.validateDeleteId(id);
-            let sql = `DELETE FROM ${this.TableName} WHERE id = $1`;
-            const datas = yield this.executeQuery(sql, [id]);
-            if (datas.rowCount !== 1) {
-                throw new Exception_1.UnprocessableException("301", this.errorMessages.idNotExist.replace('{id}', id));
-            }
-        });
-    }
     executeQuery(param1, vars) {
         return __awaiter(this, void 0, void 0, function* () {
             // 初期化項目

package/dist/models/Utils/MessageUtil.js

@@ -1 +1,59 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MessageUtil {
+}
+MessageUtil.optionErrorMessageEnglish = {
+    'string': '{name} should be entered as a string or number type.',
+    'string[]': '{name} should be entered as an array of string or number types.',
+    'uuid': '{name} should be entered as a UUID.',
+    'uuid[]': '{name} should be entered as an array of UUIDs.',
+    'integer': '{name} should be entered as a number.',
+    'integer[]': '{name} should be entered as an array of numbers.',
+    'real': '{name} should be entered as a number.',
+    'real[]': '{name} should be entered as an array of numbers.',
+    'bool': '{name} should be entered as a bool type, "true", "false", 0, or 1.',
+    'bool[]': '{name} should be entered as an array of bool types, "true", "false", 0, or 1.',
+    'date': '{name} should be entered in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.',
+    'date[]': '{name} should be entered as an array of dates in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as Date types.',
+    'time': '{name} should be entered in "hh:mi" format or "hh:mi:ss" format.',
+    '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}.',
+    'fk': 'The value of {name} does not exist in the table.',
+    'find': 'The specified data does not exist in the table. ({pks})'
+};
+MessageUtil.optionErrorMessageJapan = {
+    'string': '{name}はstringかnumberで入力してください。',
+    'string[]': '{name}はstringかnumberの配列で入力してください。',
+    'uuid': '{name}はuuidで入力してください。',
+    'uuid[]': '{name}はuuidの配列で入力してください。',
+    'integer': '{name}はnumberか半角数字のstring型で入力してください。',
+    'integer[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
+    'real': '{name}はnumberか半角数字のstring型で入力してください。',
+    'real[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
+    'bool': '{name}はbool型、"true"、"false"、0、または1で入力してください。',
+    'bool[]': '{name}はbool型、"true"、"false"、0、または1の配列で入力してください。',
+    'date': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型で入力してください。',
+    'date[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型の配列で入力してください。',
+    'time': '{name}は"hh:mi"形式または"hh:mi:ss"形式で入力してください。',
+    '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}を入力してください。',
+    'fk': '{name}の値がテーブルに存在しません。',
+    'find': '指定されたデータはテーブルに存在しません。({pks})'
+};
+exports.default = MessageUtil;

package/package.json

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

package/src/models/TableModel.ts

@@ -7,6 +7,7 @@ import ValidateClient from './ValidateClient';
 import { DbConflictException, UnprocessableException } from '../exceptions/Exception';
 import ExpressionClient from './ExpressionClient';
 import UpdateExpression from './SqlUtils/UpdateExpression';
+import MessageUtil, { TOptionErrorMessage } from './Utils/MessageUtil';
 
 export class TableModel {
 
@@ -69,7 +70,7 @@ export class TableModel {
 
     private selectExpressions: Array<string> = [];
     private joinConditions: Array<{
-        type: 'inner' | 'left',
+        type: 'inner' | 'left' | 'full',
         model: TableModel,
         conditions: Array<TNestedCondition>
     }> = [];
@@ -82,7 +83,12 @@ export class TableModel {
         let sql = ` FROM ${this.TableName} as "${this.TableAlias}"`;
 
         for (const join of this.joinConditions) {
-            sql += join.type === 'left' ? ' LEFT OUTER JOIN' : ' INNER JOIN';
+            const joins = {
+                inner: ' INNER JOIN',
+                left: ' LEFT OUTER JOIN',
+                full: ' FULL OUTER JOIN',
+            }
+            sql += joins[join.type];
             sql += ` ${join.model.TableName} as "${join.model.TableAlias}" ON `;
             const query = WhereExpression.createCondition(join.conditions, this, this.vars.length + 1);
             sql += query.expression;
@@ -138,41 +144,19 @@ export class TableModel {
         }
     }
 
-    public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null, keyFormat: TKeyFormat): Promise<T | null>;
-    public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
-    public findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null): Promise<T | null>;
-    public findId<T = {[key: string]: any}>(id: any): Promise<T | null>;
-    public async findId<T = {[key: string]: any}>(id: any, selectColumns: Array<string> | "*" | null = "*", selectExpressions: Array<TSelectExpression> | null = null, keyFormat: TKeyFormat = 'snake'): Promise<T | null> {
-        ValidateValueUtil.validateId(this.Columns, id);
-
-        let selects: Array<string> = [];
-        if (selectColumns == "*") {
-            for (const key of Object.keys(this.Columns)) {
-                selects.push(SelectExpression.create({model: this, name: key}, null, null, keyFormat));
-            }
-        } else if (selectColumns != null) {
-            for (const key of selectColumns) {
-                selects.push(SelectExpression.create({model: this, name: key}, null, null, keyFormat));
-            }
-        }
-
-        if (selectExpressions != null) {
-            for (const expression of selectExpressions) {
-                selects.push(`${expression.expression} as "${expression.alias}"`);
-            }
-        }
-
-        const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE id = $1`;
-        let datas = await this.executeQuery(sql, [id]);
-
-        return datas.rowCount == 0 ? null : datas.rows[0] as T;
-    }
-
-    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>;
-    public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null): Promise<T | null>;
     public find<T = {[key: string]: any}>(pk: {[key: string]: any}): Promise<T | null>;
-    public async find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null = "*", selectExpressions: Array<TSelectExpression> | null = null, keyFormat: TKeyFormat = 'snake'): Promise<T | null> {
+    public find<T = {[key: string]: any}>(id: string | number | boolean): Promise<T | null>;
+    public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null): Promise<T | null>;
+    public find<T = {[key: string]: any}>(id: string | number | boolean, selectColumns: Array<string> | "*" | null): Promise<T | null>;
+    public find<T = {[key: string]: any}>(pk: {[key: string]: any}, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
+    public find<T = {[key: string]: any}>(id: string | number | boolean, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null): Promise<T | null>;
+    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}>(id: string | number | boolean, selectColumns: Array<string> | "*" | null, selectExpressions: Array<TSelectExpression> | null, keyFormat: TKeyFormat): Promise<T | null>;
+    public async find<T = {[key: string]: any}>(
+        pkOrId: string | number | boolean | {[key: string]: any}, 
+        selectColumns: Array<string> | "*" | null = "*", 
+        selectExpressions: Array<TSelectExpression> | null = null, 
+        keyFormat: TKeyFormat = 'snake'): Promise<T | null> {
 
         let selects: Array<string> = [];
         if (selectColumns == "*") {
@@ -191,10 +175,16 @@ export class TableModel {
             }
         }
 
-        const {expression, vars} = WhereExpression.createConditionPk(this, pk);
+        let query: TQuery;
+        if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+            ValidateValueUtil.validateId(this.Columns, pkOrId);
+            query = WhereExpression.createConditionPk(this, {id: pkOrId});    
+        } else {
+            query = WhereExpression.createConditionPk(this, pkOrId);
+        }
  
-        const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE ${expression}`;
-        let datas = await this.executeQuery(sql, vars);
+        const sql = `SELECT ${selects.join(',')} FROM ${this.TableName} WHERE ${query.expression}`;
+        let datas = await this.executeQuery(sql, query.vars);
 
         return datas.rowCount == 0 ? null : datas.rows[0] as T;
     }
@@ -263,7 +253,7 @@ export class TableModel {
      * @param joinBaseModel 結合する対象のBaseModelインスタンスを指定します。
      * @param conditions 結合条件を指定します。条件はオブジェクトまたは文字列で指定できます。
      */
-    public join(joinType: 'left' | 'inner', joinModel: TableModel, conditions: Array<TNestedCondition>): void {
+    public join(joinType: 'left' | 'inner' | 'full', joinModel: TableModel, conditions: Array<TNestedCondition>): void {
         this.joinConditions.push({type: joinType, model: joinModel, conditions: conditions});
     }
 
@@ -393,64 +383,10 @@ export class TableModel {
         return { datas: data.rows as Array<T>, count: Number(countData.rows[0].count), lastPage: Math.ceil(Number(countData.rows[0].count) / this.PageCount)};
     }
 
-    private readonly errorMessageEnglish: Record<TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist' | 'find', string> = {
-        'string': '{name} should be entered as a string or number type.',
-        'string[]': '{name} should be entered as an array of string or number types.',
-        'uuid': '{name} should be entered as a UUID.',
-        'uuid[]': '{name} should be entered as an array of UUIDs.',
-        'integer': '{name} should be entered as a number.',
-        'integer[]': '{name} should be entered as an array of numbers.',
-        'real': '{name} should be entered as a number.',
-        'real[]': '{name} should be entered as an array of numbers.',
-        'bool': '{name} should be entered as a bool type, "true", "false", 0, or 1.',
-        'bool[]': '{name} should be entered as an array of bool types, "true", "false", 0, or 1.',
-        'date': '{name} should be entered in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.',
-        'date[]': '{name} should be entered as an array of dates in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as Date types.',
-        'time': '{name} should be entered in "hh:mi" format or "hh:mi:ss" format.',
-        '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}.',
-        'fk': 'The value of {name} does not exist in the table.',
-        'idNotExist': 'The specified ID({id}) does not exist in the table.',
-        'find': 'The specified data does not exist in the table. ({pks})'
-    }
-    private readonly errorMessageJapan: Record<TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist' | 'find', string> = {
-        'string': '{name}はstringかnumberで入力してください。',
-        'string[]': '{name}はstringかnumberの配列で入力してください。',
-        'uuid': '{name}はuuidで入力してください。',
-        'uuid[]': '{name}はuuidの配列で入力してください。',
-        'integer': '{name}はnumberか半角数字のstring型で入力してください。',
-        'integer[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
-        'real': '{name}はnumberか半角数字のstring型で入力してください。',
-        'real[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
-        'bool': '{name}はbool型、"true"、"false"、0、または1で入力してください。',
-        'bool[]': '{name}はbool型、"true"、"false"、0、または1の配列で入力してください。',
-        'date': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型で入力してください。',
-        'date[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型の配列で入力してください。',
-        'time': '{name}は"hh:mi"形式または"hh:mi:ss"形式で入力してください。',
-        '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}を入力してください。',
-        'fk': '{name}の値がテーブルに存在しません。',
-        'idNotExist': '指定されたID({id})はテーブルに存在しません。',
-        'find': '指定されたデータはテーブルに存在しません。({pks})'
-    }
+    protected readonly errorMessages: TOptionErrorMessage = 
+        process.env.TZ === 'Asia/Tokyo' ? MessageUtil.optionErrorMessageJapan : MessageUtil.optionErrorMessageEnglish;
 
-    private throwException(code: string, type: TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist', columnName: string, vallue: any): never {
+    private throwException(code: string, type: TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk', columnName: string, value: any): never {
         const column = this.getColumn(columnName);
         
         let message = this.errorMessages[type];
@@ -464,9 +400,6 @@ export class TableModel {
         throw new UnprocessableException(code, message);
     }
 
-    protected readonly errorMessages: Record<TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'idNotExist' | 'find', string> = 
-        process.env.TZ === 'Asia/Tokyo' ? this.errorMessageJapan : this.errorMessageEnglish;
-
     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.');
@@ -513,6 +446,17 @@ export class TableModel {
 
         // 外部キー制約チェック
         if (isInsert) {
+            for (const key in this.Columns) {
+                const column = this.getColumn(key);
+                const name = (column.alias === undefined || column.alias === '') ? key : column.alias;
+                if (options[key] === undefined || options[key] === null) {
+                    // Null許容されていないカラムにNULLを入れようとしているか？
+                    if (column.attribute === "primary" || column.attribute === "noDefault") {
+                        this.throwException("005", "notInput", key, options[key]);
+                    }
+                }
+            }
+
             for (const ref of this.References) {
                 const refValues = ref.columns.map(col => options[col.target]);
                 // 全ての値がnullの場合はスキップ
@@ -523,7 +467,7 @@ export class TableModel {
                 // 一部の値がnullの場合はエラー
                 if (refValues.some(value => value === null || value === undefined)) {
                     const name = ref.columns.map(col => this.getColumn(col.target).alias ?? this.getColumn(col.target).columnName).join(',');
-                    throw new UnprocessableException("005", this.errorMessages.null.replace('{name}', name));
+                    throw new UnprocessableException("006", this.errorMessages.null.replace('{name}', name));
                 }
 
                 let refIndex = 1;
@@ -531,33 +475,14 @@ export class TableModel {
                 const datas = await this.clientQuery(sql, refValues);
                 if (datas.rows[0].count == "0") {
                     const name = ref.columns.map(col => this.getColumn(col.target).alias ?? this.getColumn(col.target).columnName).join(',');
-                    throw new DbConflictException("006", this.errorMessages.fk.replace('{name}', name));
+                    throw new DbConflictException("007", this.errorMessages.fk.replace('{name}', name));
                 }
             }
         }
     }
 
-    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;
-            if (options[key] === undefined || options[key] === null) {
-                // Null許容されていないカラムにNULLを入れようとしているか？
-                if (column.attribute === "primary" || column.attribute === "noDefault") {
-                    this.throwException("101", "notInput", key, options[key]);
-                }
-            }
-        }
-    }
-
-    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: {[key: string]: any}) : Promise<void> {
+    public async insert(options: {[key: string]: any}) : Promise<void> {
         await this.validateOptions(options, true);
-        await this.validateInsert(options);
 
         const columns: Array<string> = [];
         const vars: Array<any> = [];
@@ -576,9 +501,43 @@ export class TableModel {
         await this.executeQuery(sql, vars);
     }
 
+    public async update(pkOrId: string | number | boolean | {[key: string]: any}, options: {[key: string]: any}) : Promise<void> {
+        await this.validateOptions(options, false);
+
+        const updateSetQuery = UpdateExpression.createUpdateSet(this, options);
+        let whereQuery: TQuery;
+        if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+            ValidateValueUtil.validateId(this.Columns, pkOrId);
+            whereQuery = WhereExpression.createConditionPk(this, {id: pkOrId}, updateSetQuery.vars);    
+        } else {
+            whereQuery = WhereExpression.createConditionPk(this, pkOrId, updateSetQuery.vars);
+        }
+
+        const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
+        const data = await this.executeQuery(sql, whereQuery.vars);
+        if (data.rowCount !== 1) {
+            throw new UnprocessableException("201", this.errorMessages.find.replace('{pks}', (whereQuery.vars ?? []).join(',')));
+        }
+    }
+
+    public async delete(pkOrId: string | number | boolean | {[key: string]: any}) : Promise<void> {
+        let whereQuery: TQuery;
+        if (typeof pkOrId === 'string' || typeof pkOrId === 'number' || typeof pkOrId === 'boolean') {
+            ValidateValueUtil.validateId(this.Columns, pkOrId);
+            whereQuery = WhereExpression.createConditionPk(this, {id: pkOrId});    
+        } else {
+            whereQuery = WhereExpression.createConditionPk(this, pkOrId);
+        }
+
+        const sql = `DELETE FROM ${this.TableName} WHERE ${whereQuery.expression}`;
+        const data = await this.executeQuery(sql, whereQuery.vars);
+        if (data.rowCount !== 1) {
+            throw new UnprocessableException("301", this.errorMessages.find.replace('{pks}', (whereQuery.vars ?? []).join(',')));
+        }
+    }
+
     public async executeUpdate(options: {[key: string]: any}) : Promise<number> {
         await this.validateOptions(options, false);
-        await this.validateUpdate(options);
 
         const updateExpressions: Array<string> = [];
         for (const [key, value] of Object.entries(options)) {
@@ -612,41 +571,7 @@ export class TableModel {
         return data.rowCount;
     }
 
-    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);
-        await this.validateUpdate(options);
-
-        const updateSetQuery = UpdateExpression.createUpdateSet(this, options);
-        const whereQuery = WhereExpression.createConditionPk(this, {id: id}, updateSetQuery.vars);
-
-        const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
-
-        const data = await this.executeQuery(sql, whereQuery.vars);
-        if (data.rowCount !== 1) {
-            throw new UnprocessableException("201", this.errorMessages.find.replace('{pks}', (whereQuery.vars ?? []).join(',')));
-        }
-    }
-
-    public async executeUpdateByPk(pk: {[key: string]: any}, options: {[key: string]: any}) : Promise<void> {
-        await this.validateOptions(options, false);
-        // await this.validateUpdateId(id, options);
-        await this.validateUpdate(options);
-
-        const updateSetQuery = UpdateExpression.createUpdateSet(this, options);
-        const whereQuery = WhereExpression.createConditionPk(this, pk, updateSetQuery.vars);
-
-        const sql = updateSetQuery.expression + ' WHERE ' + whereQuery.expression;
-
-        const data = await this.executeQuery(sql, whereQuery.vars);
-        if (data.rowCount !== 1) {
-            throw new UnprocessableException("401", this.errorMessages.find.replace('{pks}', (whereQuery.vars ?? []).join(',')));
-        }
-    }
-
     public async executeDelete() : Promise<number> {
-        this.validateDelete();
         let sql = `DELETE FROM ${this.TableName} "${this.TableAlias}" `;
 
         if (this.joinConditions.length > 0) {
@@ -671,17 +596,6 @@ export class TableModel {
         return datas.rowCount;
     }
 
-    public async executeDeleteId(id: any) : Promise<void> {
-        ValidateValueUtil.validateId(this.Columns, id);
-        await this.validateDeleteId(id);
-        let sql = `DELETE FROM ${this.TableName} WHERE id = $1`;
-
-        const datas = await this.executeQuery(sql, [id]);
-        if (datas.rowCount !== 1) {
-            throw new UnprocessableException("301", this.errorMessages.idNotExist.replace('{id}', id));
-        }
-    }
-
     protected executeQuery(param1: string, vars?: Array<any>) : Promise<any>;
     protected executeQuery(param1: TQuery) : Promise<any>;
     protected async executeQuery(param1: string | TQuery, vars?: Array<any>) : Promise<any> {

package/src/models/Utils/MessageUtil.ts

@@ -0,0 +1,60 @@
+import { TColumnArrayType, TColumnType } from "../Type"
+
+export type TOptionErrorMessage = Record<TColumnType | TColumnArrayType | 'length' | 'null' | 'notInput' | 'fk' | 'find', string>;
+
+export default class MessageUtil {
+    public static readonly optionErrorMessageEnglish: TOptionErrorMessage = {
+        'string': '{name} should be entered as a string or number type.',
+        'string[]': '{name} should be entered as an array of string or number types.',
+        'uuid': '{name} should be entered as a UUID.',
+        'uuid[]': '{name} should be entered as an array of UUIDs.',
+        'integer': '{name} should be entered as a number.',
+        'integer[]': '{name} should be entered as an array of numbers.',
+        'real': '{name} should be entered as a number.',
+        'real[]': '{name} should be entered as an array of numbers.',
+        'bool': '{name} should be entered as a bool type, "true", "false", 0, or 1.',
+        'bool[]': '{name} should be entered as an array of bool types, "true", "false", 0, or 1.',
+        'date': '{name} should be entered in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as a Date type.',
+        'date[]': '{name} should be entered as an array of dates in "YYYY-MM-DD" or "YYYY-MM-DD hh:mi:ss" format or as Date types.',
+        'time': '{name} should be entered in "hh:mi" format or "hh:mi:ss" format.',
+        '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}.',
+        'fk': 'The value of {name} does not exist in the table.',
+        'find': 'The specified data does not exist in the table. ({pks})'
+    }
+    public static readonly optionErrorMessageJapan: TOptionErrorMessage = {
+        'string': '{name}はstringかnumberで入力してください。',
+        'string[]': '{name}はstringかnumberの配列で入力してください。',
+        'uuid': '{name}はuuidで入力してください。',
+        'uuid[]': '{name}はuuidの配列で入力してください。',
+        'integer': '{name}はnumberか半角数字のstring型で入力してください。',
+        'integer[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
+        'real': '{name}はnumberか半角数字のstring型で入力してください。',
+        'real[]': '{name}はnumberか半角数字のstring型の配列で入力してください。',
+        'bool': '{name}はbool型、"true"、"false"、0、または1で入力してください。',
+        'bool[]': '{name}はbool型、"true"、"false"、0、または1の配列で入力してください。',
+        'date': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型で入力してください。',
+        'date[]': '{name}は"YYYY-MM-DD"形式、"YYYY-MM-DD hh:mi:ss"形式、またはDate型の配列で入力してください。',
+        'time': '{name}は"hh:mi"形式または"hh:mi:ss"形式で入力してください。',
+        '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}を入力してください。',
+        'fk': '{name}の値がテーブルに存在しません。',
+        'find': '指定されたデータはテーブルに存在しません。({pks})'
+    }
+}