pg-mvc-service 1.0.0

package/src/models/Type.ts

@@ -0,0 +1,59 @@
+import { TableModel } from "./TableModel";
+
+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 TColumnDetail = TColumn & {
+    columnName: string,
+    tableName: string,
+    expression: string
+}
+
+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};

package/src/models/Utils/DateTimeUtil.ts

@@ -0,0 +1,146 @@
+export default class DateTimeUtil {
+
+    /**
+     * Checks if the value is a valid date-time format
+     * 値が有効な日付時間形式かどうかを確認します
+     * @param value - 検証する値, The value to be validated
+     * @returns {boolean} - 値が有効な日付時間形式であるかどうか, Whether the value is a valid date-time format
+     */
+    private static isErrorDateTime(value: string): boolean {
+        try {
+            const [datePart, timePart] = value.split(' ');
+            const [year, month, day] = datePart.split('-').map(Number);
+            let [hour, minute, sec] = [0, 0, 0];
+            if (timePart !== undefined) {
+                [hour, minute, sec] = timePart.split(':').map(Number);
+            }
+            
+            const date = new Date(year, month - 1, day, hour, minute, sec);
+            return year !== date.getFullYear() || 
+                   month !== date.getMonth() + 1 || 
+                   day !== date.getDate() ||
+                   hour !== date.getHours() ||
+                   minute !== date.getMinutes() ||
+                   sec !== date.getSeconds()
+        } catch (error) {
+            return true;
+        }
+    }
+
+    /**
+     * Generates a Date object from a string.
+     * 文字列からDateオブジェクトを生成します。
+     * @param dateString A string representing the date and time (e.g., "2023-10-05 14:30:00")
+     * 日付と時間を表す文字列（例: "2023-10-05 14:30:00"）
+     * @returns Date object
+     * Dateオブジェクト
+     */
+    static toDateFromString(dateString: string): Date {
+        const [datePart, timePart] = dateString.split(' ');
+        const [year, month, day] = datePart.split('-').map(Number);
+        let [hours, minutes, seconds] = [0, 0, 0];
+        if (timePart !== undefined) {
+            [hours, minutes, seconds] = timePart.split(':').map(Number);
+        }
+        return new Date(year, month - 1, day, hours, minutes, seconds);
+    }
+
+    /**
+     * Formats the specified date.
+     * 指定された日付をフォーマットします。
+     * @param date The date object to be formatted.
+     * フォーマットする対象の日付オブジェクト
+     * @param type A string specifying the type of format.
+     * フォーマットの種類を指定する文字列
+     * @returns A formatted date string.
+     * フォーマットされた日付文字列
+     */
+    static toStringFromDate(date: Date, type: 'datetime' | 'date' | 'time'): string {
+
+        const year = date.getFullYear().toString().padStart(4, '0');
+        const month = (date.getMonth() + 1).toString().padStart(2, '0');
+        const day = date.getDate().toString().padStart(2, '0');
+        const hour = date.getHours().toString().padStart(2, '0');
+        const minute = date.getMinutes().toString().padStart(2, '0');
+        const second = date.getSeconds().toString().padStart(2, '0');
+
+        switch (type) {
+            case 'datetime':
+                return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+            case 'date':
+                return `${year}-${month}-${day}`;
+            case 'time':
+                return `${hour}:${minute}:${second}`;
+            default:
+                throw new Error('Invalid type');
+        }
+    }
+
+    /**
+     * Validates if the given value is in the format YYYY-MM-DD
+     * 与えられた値がYYYY-MM-DD形式であるかどうかを検証します
+     * @param value - The value to be validated, 検証する値
+     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD, 値がYYYY-MM-DD形式であるかどうか
+     */
+    static isYYYYMMDD(value: any) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+
+        const pattern = new RegExp('^\\d{4}-\\d{2}-\\d{2}$');
+        if (pattern.test(value) === false) {
+            return false;
+        }
+
+        return this.isErrorDateTime(value) === false;
+    }
+
+    /**
+     * Validates if the given value is in the format YYYY-MM-DD hh:mm:ss
+     * 与えられた値がYYYY-MM-DD hh:mm:ss形式であるかどうかを検証します
+     * @param value - The value to be validated, 検証する値
+     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD hh:mm:ss, 値がYYYY-MM-DD hh:mm:ss形式であるかどうか
+     */
+    static isYYYYMMDDhhmiss(value: any) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+
+        const pattern = new RegExp('^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}:\\d{2}$');
+        if (pattern.test(value) === false) {
+            return false;
+        }
+
+        return this.isErrorDateTime(value) === false;
+    }
+
+    /**
+     * Validates if the given value is in the format YYYY-MM-DD hh:mm:ss
+     * 与えられた値がYYYY-MM-DD hh:mm:ss形式であるかどうかを検証します
+     * @param value - The value to be validated, 検証する値
+     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD hh:mm:ss, 値がYYYY-MM-DD hh:mm:ss形式であるかどうか
+     */
+    static isHHMM(value: any) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+
+        const pattern = new RegExp('^(?:[01]\\d|2[0-3]):[0-5]\\d$');
+        return pattern.test(value);
+    }
+
+    /**
+     * Validates if the given value is in the format HH:MM:SS
+     * 与えられた値がHH:MM:SS形式であるかどうかを検証します
+     * @param value - The value to be validated, 検証する値
+     * @returns {boolean} - Whether the value is in the format HH:MM:SS, 値がHH:MM:SS形式であるかどうか
+     */
+    static isHHMMSS(value: any) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+
+        const pattern = new RegExp('^(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d$');
+        return pattern.test(value);
+    }
+}

package/src/models/Utils/NumberUtil.ts

@@ -0,0 +1,23 @@
+export default class NumberUtil {
+    /**
+     * Checks if the given value is a number.
+     * 与えられた値が数値であるかどうかを確認します。
+     * @param value - The value to be checked. ���認する値。
+     * @returns {boolean} - Whether the value is a number. ��が数値であるかどうか。
+     */
+    static isNumber(value: any) {
+        if (value == null) {
+            return false;
+        } else if (value instanceof Date) { 
+            return false;
+        } else if (value instanceof Array) {
+            return false;
+        } else if (typeof(value) == 'string') {
+            if (value == "") {
+                return false;
+            }
+        }
+
+        return isNaN(Number(value)) == false;
+    }
+}

package/src/models/Utils/StringUtil.ts

@@ -0,0 +1,33 @@
+export default class StringUtil {
+    /**
+     * Validates if the given value is a valid UUID
+     * 与えられた値が有効なUUIDであるかどうかを検証します
+     * @param value - The value to be validated, 検証する値
+     * @returns {boolean} - Whether the value is a valid UUID, 値が有効なUUIDであるかどうか
+     */
+    static isUUID(value: any) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+
+        const pattern = new RegExp('^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$');
+        return pattern.test(value);
+    }
+
+    /**
+     * 小文字スネークからキャピタルケースに変換
+     * @param {string} value スネーク文字列
+     * @returns キャピタル文字列
+     */
+    static formatFromSnakeToCamel(value: string) {
+        const regex = /_[a-z]/g;
+        let capital = value.replace(regex,
+            function(matchChar) {
+                return String.fromCharCode(matchChar.charCodeAt(1) - 0x20);
+            }
+        );
+    
+        // "_1"や"_@"のパターンを考慮して、_を省く（この使い方はあまりないと思いますが...）
+        return capital.replaceAll("_", "");
+    }
+}

package/src/models/ValidateClient.ts

@@ -0,0 +1,182 @@
+import { TableModel } from "./TableModel";
+import { TOption, TSqlValue } from "./Type";
+
+type TError = {code?: string; message?: string;};
+
+export default class ValidateClient {
+    private model: TableModel;
+    constructor(model: TableModel) {
+        this.model = model;
+    }
+    
+    public tryDate(value: any, isExcludeTime: boolean = false): Date | false {
+        if (value instanceof Date) {
+            return value;
+        } else if (typeof value !== 'string') {
+            return false;
+        }
+
+        try {
+            const [datePart, timePart] = value.split(' ');
+            const [year, month, day] = datePart.split('-').map(Number);
+            let [hours, minutes, seconds] = [0, 0, 0];
+            if (timePart !== undefined && isExcludeTime === false) {
+                [hours, minutes, seconds] = timePart.split(':').map(Number);
+            }
+
+            // 日付の整合性チェック
+            const date = new Date(year, month - 1, day, hours, minutes, seconds);
+            if (date.getFullYear() !== year || 
+                date.getMonth() + 1 !== month || 
+                date.getDate() !== day ||
+                date.getHours() !== hours ||
+                date.getMinutes() !== minutes ||
+                date.getSeconds() !== seconds
+            ) {
+                return false;
+            }
+            
+            return date;
+        } catch (ex) {
+            return false;
+        }
+    }
+
+    public validateInList(option: TOption, key: string, list: Array<TSqlValue>, error?: TError) {
+        const column = this.model.getColumn(key);
+        const value = option[key];
+        if (value === undefined || value === null || value === "") {
+            return;
+        }
+        
+        if (list.includes(value) === false) {
+            const code = error?.code ?? "000";
+            let message = error?.message;
+            if (message === undefined) {
+                message = `{column} must be one of the items in the {list}. ({value})`;
+            }
+            message = message.replace('{column}', column.alias ?? column.columnName);
+            message = message.replace('{value}', value.toString());
+            message = message.replace('{list}', list.join(', '));
+            this.model.throwValidationError(code, message);
+        }
+    }
+
+    public validateUnderNow(option: TOption, key: string, error?: TError) {
+        const column = this.model.getColumn(key);
+        const value = option[key];
+        if (value === undefined || value === null || value === "") {
+            return;
+        }
+
+        const date = this.tryDate(value);
+        if (date === false) {
+            throw new Error("The value must be a Date or a valid date string  when using validateUnderNow.");
+        }
+
+        const now = new Date();
+        if (date > now) {
+            const code = error?.code ?? "000";
+            let message = error?.message;
+            if (message === undefined) {
+                message = `{column} should be entered on or before now. ({value})`;
+            }
+            message = message.replace('{column}', column.alias ?? column.columnName);
+            message = message.replace('{value}', value.toString());
+            this.model.throwValidationError(code, message);
+        }
+    }
+
+    public validateUnderToday(option: TOption, key: string, isErrorToday: boolean, error?: TError): void {
+        const column = this.model.getColumn(key);
+        const value = option[key];
+        if (value === undefined || value === null || value === "") {
+            return;
+        }
+
+        const date = this.tryDate(value);
+        if (date === false) {
+            throw new Error("The value must be a Date or a valid date string when using validateUnderToday.");
+        }
+
+        date.setHours(0);
+        date.setMinutes(0);
+        date.setSeconds(0);
+        date.setMilliseconds(0);
+
+        const today = new Date();
+        today.setHours(0);
+        today.setMinutes(0);
+        today.setSeconds(0);
+        today.setMilliseconds(isErrorToday ? 0 : 1);
+
+        if (date >= today) {
+            const code = error?.code ?? "000";
+            let message = error?.message;
+            if (message === undefined) {
+                if (isErrorToday) {
+                    message = `{column} should be entered before today. ({value})`;
+                } else {
+                    message = `{column} should be entered on or before today. ({value})`;
+                }
+            }
+            message = message.replace('{column}', column.alias ?? column.columnName);
+            message = message.replace('{value}', value.toString());
+            this.model.throwValidationError(code, message);
+        }
+    }
+
+    public validateRegExp(option: TOption, key: string, regExp: RegExp | string, error?: TError): void {
+        const column = this.model.getColumn(key);
+        const value = option[key];
+        if (value === undefined || value === null || value === "") {
+            return;
+        }
+
+        if (typeof value !== 'string') {
+            throw new Error("The value must be a string when using validateStringRegExp.");
+        }
+
+        if (typeof regExp === 'string') {
+            regExp = new RegExp(regExp);
+        }
+
+        if (regExp.test(value) === false) {
+            const code = error?.code ?? "000";
+            let message = error?.message;
+            if (message === undefined) {
+                message = `{column} is invalid. ({value})`;
+            }
+            message = message.replace('{column}', column.alias ?? column.columnName);
+            message = message.replace('{value}', value.toString());
+            this.model.throwValidationError(code, message);
+        }
+    }
+
+    public validatePositiveNumber(option: TOption, key: string, error?: TError) {
+        const column = this.model.getColumn(key);
+        const value = option[key];
+        if (value === undefined || value === null || value === "") {
+            return;
+        }
+
+        if (typeof value !== 'number' && typeof value !== 'string') {
+            throw new Error("The value must be a valid number string or number when using validatePositiveNumber.");
+        }
+
+        if (isNaN(Number(value))) {
+            throw new Error("The value must be a valid number string or number when using validatePositiveNumber.");
+        }
+
+        if (Number(value) <= 0) {
+            const code = error?.code ?? "000";
+            let message = error?.message;
+            if (message === undefined) {
+                message = `Please enter a value greater than 0 for {column}. ({value})`;
+            }
+            message = message.replace('{column}', column.alias ?? column.columnName);
+            message = message.replace('{value}', value.toString());
+            this.model.throwValidationError(code, message);
+        }
+    }
+}

package/src/models/index.ts

@@ -0,0 +1,7 @@
+export { TableModel } from './TableModel';
+export { createTableDoc } from './TableDoc';
+
+export { MigrateTable } from './MigrateTable'; 
+export { migrate, rollback } from './MigrateRollback';
+
+export { MigrateDatabase } from './MigrateDatabase';