pg-mvc-service 2.1.0 → 2.1.2

package/index.d.ts

@@ -1,192 +0,0 @@
-import { AxiosResponse } from "axios";
-import { Request, Response } from 'express';
-import { Pool, PoolClient } from 'pg';
-import { ErrorMessageType, IncomingHttpHeaders } from './src/reqestResponse/RequestType';
-import { ArrayType, EnumType, MapType, NumberType, ObjectType, PrimitiveType, StringType } from './src/reqestResponse/ReqResType';
-
-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';
-
-import { TableModel } from "./src/models/TableModel";
-export { TableModel } from "./src/models/TableModel";
-
-import { WhereExpression } from './src/models/SqlUtils/WhereExpression';
-export { WhereExpression } from './src/models/SqlUtils/WhereExpression';
-
-export { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
-
-export { DayType, MonthType, DateType, HourType, MinuteSecondType } from './src/cron/CronType';
-export { BaseCron } from "./src/cron/BaseCron";
-export { runCron } from "./src/cron/CronExecuter";
-
-declare module 'pg-mvc-service' {
-    export class Service {
-        protected readonly method: MethodType;
-        get Method(): MethodType;
-        protected readonly endpoint: string;
-        get Endpoint(): string;
-        protected readonly apiCode: string;
-        get ApiCode(): string;
-        protected readonly summary: string;
-        get Summary(): string;
-        protected readonly apiUserAvailable: string;
-        get ApiUserAvailable(): string;
-        protected readonly request: RequestType;
-        get AuthToken(): string;
-        protected readonly response: ResponseType;
-        protected readonly isTest: boolean;
-        protected readonly tags: Array<string>;
-        get Tags(): Array<string>;
-
-        protected readonly req: Request;
-        protected readonly res: Response;
-        constructor(request: Request, response: Response);
-
-        public inintialize(): void;
-
-        protected dbUser?: string;
-        protected dbHost?: string;
-        protected dbName?: string;
-        protected dbPassword?: string;
-        protected dbPort?: number;
-        protected dbIsSslConnect?: boolean;
-        protected checkMaintenance(): Promise<void>;
-        protected middleware(): Promise<void>;
-
-        public resSuccess(): void;
-        public handleException(ex: any): void;
-        protected outputErrorLog(ex: any): Promise<void>;
-
-        protected get Pool(): Pool;
-        protected get Client(): PoolClient;
-
-        public startConnect(): Promise<void>;
-        public commit(): Promise<void>;
-        public rollback(): Promise<void>;
-        public release(): Promise<void>;
-
-        get S3Client(): AwsS3Client;
-        get Base64Client(): Base64Client;
-        get StringClient(): StringClient;
-        get EncryptClient(): EncryptClient;
-
-        public requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
-            method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>>;
-    }
-
-    export interface IParams {
-        in: 'header' | 'path',
-        name: string,
-        require?: boolean,
-        description?: string,
-        example?: string
-    }
-    export function createSwagger(services: Service[], name: string, url: string, params: Array<IParams>): string;
-
-    export type PropertyType =  PrimitiveType | StringType | NumberType | ObjectType | ArrayType | EnumType | MapType;
-
-    export class RequestType {
-        constructor();
-
-        protected properties: { [key: string]: PropertyType; };
-        protected paramProperties: Array<(PrimitiveType | StringType | NumberType | EnumType) & { key: string }>;
-        protected readonly ERROR_MESSAGE: ErrorMessageType;
-
-        protected throwException(code: string, message: string): never;
-
-        public setRequest(request: Request): void;
-        get Data(): { [key: string]: any };
-        get Headers(): IncomingHttpHeaders;
-        get Params(): { [key: string]: any };
-        get RemoteAddress(): string | undefined;
-        get Authorization(): string | null;
-    }
-
-    export class ResponseType {
-        public Data: { [key: string]: any };
-
-        protected properties: { [key: string]: PropertyType; };
-        get ResponseData(): { [key: string]: any };
-    }
-
-    export class AuthException extends Error {
-        private id: string;
-        get Id(): string;
-        constructor(id: string, message?: string);
-    }
-
-    export class ForbiddenException extends Error {
-    }
-
-    export class InputErrorException extends Error {
-        private errorId: string;
-        get ErrorId(): string;
-        private errorLog: string;
-        get ErrorLog(): string;
-        constructor(errorId: string, message?: string, errorLog?: string);
-    }
-
-    export class MaintenanceException extends Error {
-        constructor(message?: string);
-    }
-
-    export class DbConflictException extends Error {
-        private errorId: string;
-        get ErrorId(): string;
-        constructor(errorId: string, message?: string);
-    }
-
-    export class NotFoundException extends Error {
-        private errorId: string;
-        get ErrorId(): string;
-        constructor(errorId: string, message?: string);
-    }
-
-    export class UnprocessableException extends Error {
-        private errorId: string;
-        get ErrorId(): string;
-        constructor(errorId: string, message?: string);
-    }
-
-    export function createTableDoc(models: Array<TableModel>, serviceName?: string): string;
-    export function migrate(migrates: Array<MigrateTable>, poolParam: {
-        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
-    }): Promise<void>;
-    export function rollback(toNumber: number, poolParam: {
-        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
-    }): Promise<void>;
-    export class MigrateTable {
-        protected readonly migrateSql: string;
-        protected readonly rollbackSql: string;
-        protected readonly addGrantTables: Array<string>;
-        protected readonly user: string;
-
-        constructor();
-        constructor(user: string);
-    }
-
-    export class MigrateDatabase {
-        constructor(dbName: string, userName: string, pool: Pool);
-    
-        get DbName(): string;
-        get UserName(): string;
-        get Password(): string | null;
-    
-        public IsExistUser(): Promise<boolean>;
-        public CreateUser(password?: string): Promise<void>;
-        public IsExistDb(): Promise<boolean>;
-        public CreateDb(collateType?: string): Promise<void>;
-        public RollbackDbSql(): string;
-        public RollbackUserSql(otherUserName: string): string;
-    }
-}

package/src/PoolManager.ts

@@ -1,48 +0,0 @@
-// PoolManager.ts
-import { Pool } from 'pg';
-
-export default class PoolManager {
-    private static poolMap: Record<string, Pool> = {};
-
-    static getPool(user: string, host: string, database: string, password: string, port: number | string, isSslConnect: boolean): Pool {
-        const key = `${user}@${host}/${database}`;
-        if (!this.poolMap[key]) {
-            this.poolMap[key] = new Pool({
-                user: user,
-                host: host,
-                database: database,
-                password: password,
-                port: Number(port),
-                ssl: isSslConnect ? {
-                    rejectUnauthorized: false
-                    } : false
-            });
-        }
-    
-        return this.poolMap[key];
-    }
-  
-static async shutdownAll(): Promise<void> {
-    for (const [key, pool] of Object.entries(this.poolMap)) {
-        try {
-            await pool.end();
-            console.log(`Closed pool: ${key}`);
-        } catch (e) {
-            console.error(`Error closing pool ${key}`, e);
-        }
-        }
-    }
-}
-  
-// ✅ 自動実行されるシャットダウン登録
-process.on('SIGINT', async () => {
-    console.log('🔌 SIGINT received. Closing all pools...');
-    await PoolManager.shutdownAll();
-    process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-    console.log('🔌 SIGTERM received. Closing all pools...');
-    await PoolManager.shutdownAll();
-    process.exit(0);
-});

package/src/Service.ts

@@ -1,307 +0,0 @@
-import axios, { AxiosResponse } from "axios";
-import { Request, Response } from 'express';
-import { Hono, Context } from 'hono' // Context を追加
-import { Pool, type PoolClient } from 'pg';
-import { MaintenanceException, AuthException, InputErrorException, ForbiddenException, DbConflictException, UnprocessableException, NotFoundException } from './exceptions/Exception';
-import { RequestType } from './reqestResponse/RequestType';
-import { ResponseType } from './reqestResponse/ResponseType';
-import { AwsS3Client } from './clients/AwsS3Client';
-import { Base64Client } from './clients/Base64Client';
-import { StringClient } from './clients/StringClient';
-import { EncryptClient } from './clients/EncryptClient';
-import PoolManager from './PoolManager';
-
-type TStatusCode = 200 | 201 | 400 | 401 | 403 | 404 | 409 | 422 | 500 | 503;
-
-export type MethodType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-export interface IError {
-    status: TStatusCode, 
-    code: string;
-    description: string; 
-}
-
-
-export class Service {
-    protected readonly module: 'express' | 'hono' = 'express';
-    protected readonly method: MethodType = 'GET';
-    get Method(): MethodType { return this.method; }
-    protected readonly endpoint: string = '';
-    get Endpoint(): string { return this.endpoint + this.request.paramPath; }
-    protected readonly apiCode: string = '';
-    get ApiCode(): string { return this.apiCode; }
-    protected readonly summary: string = '';
-    get Summary(): string { return `${this.ApiCode !== '' ? this.apiCode + ': ' : ''}${this.summary}`; }
-    protected readonly apiUserAvailable: string = '';
-    get ApiUserAvailable(): string { return this.apiUserAvailable; }
-    protected readonly request: RequestType = new RequestType();
-    get Request(): RequestType { return this.request }; // swaggerで必要なので、ここだけ宣言
-    get AuthToken(): string { return this.request.Authorization ?? ''; }
-    protected readonly response: ResponseType = new ResponseType();
-    get Response(): ResponseType { return this.response }; // swaggerで必要なので、ここだけ宣言
-    protected readonly tags: Array<string> = [];
-    get Tags(): Array<string> { return this.tags; }
-    protected readonly errorList: Array<IError> = [];
-    get ErrorList(): Array<IError> {
-        return [...this.errorList, {
-            status: 500,
-            code: '',
-            description: 'サーバー内部エラー（予期せぬエラー）'
-        }];
-    }
-
-    protected readonly req?: Request;
-    protected readonly res?: Response;
-    protected readonly c?: Context;
-    protected setResponse(status: TStatusCode, data: any) {
-        if (this.module === 'express') {
-            this.res?.status(status).json(data);
-        } else {
-            this.c?.json(data, status)
-        }
-    }
-
-    constructor(request: Request, response: Response);
-    constructor(c: Context);
-    constructor(param1: Request | Context, param2?: Response) {
-        if (param2 !== undefined) {
-            // Express の場合: (request, response)
-            this.module = 'express';
-            this.req = param1 as Request;
-            this.res = param2;
-        } else {
-            // Hono の場合: (c)
-            this.module = 'hono';
-            this.c = param1 as Context;
-        }
-    }
-
-    public async inintialize(): Promise<void> {
-        if (this.module === "express") {
-            await this.request.setRequest(this.module, this.req as Request);
-        } else {
-            await this.request.setRequest(this.module, this.c as Context);
-        }
-
-        await this.checkMaintenance();
-        await this.middleware();
-    }
-    // Context<{ Bindings: Bindings }>
-
-    protected dbUser?: string = process.env.DB_USER;
-    protected dbHost?: string = process.env.DB_HOST;
-    protected dbName?: string = process.env.DB_DATABASE;
-    protected dbPassword?: string = process.env.DB_PASSWORD;
-    protected dbPort?: string | number = process.env.DB_PORT;
-    protected dbIsSslConnect: boolean = process.env.DB_IS_SSL === 'true';
-    private setPool(): Pool {
-        if (this.dbUser === undefined) {
-            throw new Error("Database user is not configured");
-        }
-        if (this.dbHost === undefined) {
-            throw new Error("Database host is not configured");
-        }
-        if (this.dbName === undefined) {
-            throw new Error("Database name is not configured");
-        }
-        if (this.dbPassword === undefined) {
-            throw new Error("Database password is not configured");
-        }
-        if (this.dbPort === undefined) {
-            throw new Error("Database port is not configured");
-        }
-
-        try {
-            return PoolManager.getPool(this.dbUser, this.dbHost, this.dbName, this.dbPassword, this.dbPort, this.dbIsSslConnect);
-        } catch (ex) {
-            throw new Error("Failed to connect to the database. Please check the connection settings.");
-        }
-    }
-    protected async checkMaintenance(): Promise<void> { }
-    protected async middleware(): Promise<void>{ }
-
-    public resSuccess(): void {
-        this.setResponse(200, this.response.ResponseData);
-    }
-
-    protected async outputErrorLog(ex: any): Promise<void>{ }
-    public handleException(ex: any): void {
-        // To avoid slowing down the response, make this asynchronous
-        this.outputErrorLog(ex).catch((ex) => {
-            console.error(ex);
-        });
-
-        if (ex instanceof AuthException) {
-            this.setResponse(401, {
-                message : "Authentication expired. Please login again."
-            });
-            return;
-        } else if (ex instanceof ForbiddenException) {
-            this.setResponse(403, {
-                message : 'Forbidden error'
-            });
-            return;
-        } else if (ex instanceof InputErrorException) {
-            this.setResponse(400, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof DbConflictException) {
-            this.setResponse(409, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof UnprocessableException) {
-            this.setResponse(422, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof MaintenanceException) {
-            this.setResponse(503, {
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof NotFoundException) {
-            this.setResponse(404, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        }
-
-        this.setResponse(500, {
-            message : 'Internal server error'
-        });
-
-        return;
-    }
-
-    private pool?: Pool;
-    protected get Pool(): Pool {
-        if (this.pool === undefined) {
-            this.pool = this.setPool();
-            this.pool.query(`SET TIME ZONE '${process.env.TZ ?? 'Asia/Tokyo'}';`);
-        }
-        return this.pool; 
-    }
-    private client?: PoolClient;
-    private isExecuteRollback: boolean = false;
-    protected get Client(): PoolClient { 
-        if (this.client === undefined) {
-            throw new Error("Please call this.PoolClient after using the startConnect method.");
-        }
-        return this.client;
-    }
-
-    public async startConnect(): Promise<void> {
-        this.client = await this.Pool.connect();
-        await this.Client.query('BEGIN');
-        this.isExecuteRollback = true;
-    }
-
-    public async commit(): Promise<void> {
-        await this.Client.query('COMMIT');
-        this.isExecuteRollback = false;
-    }
-
-    public async rollback(): Promise<void> {
-        if (this.isExecuteRollback) {
-            await this.Client.query('ROLLBACK');
-        }
-        this.isExecuteRollback = false;
-    }
-
-    public async release(): Promise<void> {
-        await this.rollback();
-        if (this.client !== undefined) {
-            await this.client.release();
-        }
-    }
-
-    private s3Client?: AwsS3Client;
-    get S3Client(): AwsS3Client {
-        if (this.s3Client === undefined) {
-            this.s3Client = new AwsS3Client({
-                bucketName: process.env.S3_BUCKET_NAME,
-                region: process.env.S3_REGION,
-                accessKeyId: process.env.S3_ACCESS_KEY_ID,
-                secretAccessKey: process.env.S3_SECRET_ACCESS_KEY
-            });
-        }
-        return this.s3Client;
-    }
-
-    private base64Client? : Base64Client;
-    get Base64Client(): Base64Client {
-        if (this.base64Client === undefined) {
-            this.base64Client = new Base64Client();
-        }
-        return this.base64Client;
-    }
-
-    private stringClient? : StringClient;
-    get StringClient(): StringClient {
-        if (this.stringClient === undefined) {
-            this.stringClient = new StringClient();
-        }
-        return this.stringClient;
-    }
-
-    private encryptClient?: EncryptClient;
-    get EncryptClient(): EncryptClient {
-        if (this.encryptClient === undefined) {
-            this.encryptClient = new EncryptClient({
-                secretKeyHex: process.env.SECRET_KEY_HEX,
-                hmacKeyBase64: process.env.HMAC_KEY_BASE64
-            });
-        }
-
-        return this.encryptClient;
-    }
-
-    public async requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
-        method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>> {
-
-        // GET,DELETEのparamをURLクエリに
-        if (method === 'GET' || method === 'DELETE') {
-            for (const [key, value] of Object.entries(params as Record<string, any>)) {
-                if (value === undefined || value === null) {
-                    continue;
-                }
-
-                if (Array.isArray(value)) {
-                    for (const arrayValue of value) {
-                        url += url.includes('?') ? '&' : '?';
-                        url += `${key}=${arrayValue.toString()}`;
-                    }
-                } else {
-                    url += url.includes('?') ? '&' : '?';
-                    url += `${key}=${value.toString()}`;
-                }
-            }
-        }
-
-        try {
-            switch (method) {
-                case 'GET':
-                    return await axios.get(url, header === undefined ? {} : { headers: header });
-                case 'POST':
-                    return await axios.post(url, params, header === undefined ? {} : { headers: header });
-                case 'PUT':
-                    return await axios.put(url, params, header === undefined ? {} : { headers: header });
-                case 'DELETE':
-                    return await axios.delete(url, header === undefined ? {} : { headers: header });
-                case 'PATCH':
-                    return await axios.patch(url, params, header === undefined ? {} : { headers: header });
-            }
-        } catch (ex) {
-            let response = (ex as any).response as AxiosResponse<TResponse>;
-            if (response && [400, 401, 403, 404, 409, 422].includes(response.status)) {
-                return response;
-            }
-            throw ex;
-        }
-    }
-}

package/src/Utils/DateTimeUtil.ts

@@ -1,146 +0,0 @@
-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);
-    }
-}