pg-mvc-service 1.0.22 → 1.0.24

package/dist/models/ExpressionClient.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ExpressionClient {
+    constructor(model) {
+        this.model = model;
+    }
+    toSqlStringValue(value) {
+        if (typeof value === 'string' || typeof value === 'number') {
+            return `"${value}"`;
+        }
+        throw new Error('Please enter a value of type string or number.');
+    }
+    toSqlNumberValue(value) {
+        if (typeof value === 'number') {
+            return value.toString();
+        }
+        else if (typeof value === 'string') {
+            if (value.trim() !== "" || isNaN(Number(value)) === false) {
+                return value;
+            }
+        }
+        throw new Error('Please enter a value of type number or a string of half-width digits.');
+    }
+    createCaseFromObject(column, obj, elseValue) {
+        const columnInfo = typeof column === 'string' ? this.model.getColumn(column) : column.model.getColumn(column.name);
+        if (columnInfo.type !== 'string' && columnInfo.type !== 'integer') {
+            throw new Error('This method cannot be used for columns other than integer, real, or string.');
+        }
+        const whenExpression = Object.entries(obj).map(([key, value]) => {
+            let expression = `WHEN ${columnInfo.expression} = `;
+            // 今は文字列と数値だけだが、他のも対応しないといけないかも
+            if (columnInfo.type === 'string') {
+                expression += this.toSqlStringValue(key);
+            }
+            else {
+                expression += this.toSqlNumberValue(key);
+            }
+            expression += ` THEN `;
+            if (value === null) {
+                expression += 'null';
+            }
+            else if (typeof value === 'string') {
+                expression += `"${value}"`;
+            }
+            else if (typeof value === 'boolean') {
+                expression += `${value}`;
+            }
+            else {
+                expression += `${value}`;
+            }
+            return expression;
+        });
+        return `CASE ${whenExpression.join(' ')} END`;
+    }
+}
+exports.default = ExpressionClient;

package/dist/models/TableModel.js

@@ -18,6 +18,7 @@ const SelectExpression_1 = __importDefault(require("./SqlUtils/SelectExpression"
 const WhereExpression_1 = __importDefault(require("./SqlUtils/WhereExpression"));
 const ValidateClient_1 = __importDefault(require("./ValidateClient"));
 const Exception_1 = require("../exceptions/Exception");
+const ExpressionClient_1 = __importDefault(require("./ExpressionClient"));
 class TableModel {
     get DbName() { return this.dbName; }
     get TableName() {
@@ -92,6 +93,9 @@ class TableModel {
             this.Offset = (value - 1) * this.PageCount;
         }
     }
+    get Client() {
+        return this.client;
+    }
     constructor(client, tableAlias) {
         this.dbName = "default";
         this.tableName = "";
@@ -674,5 +678,11 @@ class TableModel {
         }
         return this.validateClient;
     }
+    get ExpressionClient() {
+        if (this.expressionClient === undefined) {
+            this.expressionClient = new ExpressionClient_1.default(this);
+        }
+        return this.expressionClient;
+    }
 }
 exports.TableModel = TableModel;

package/index.d.ts

@@ -146,87 +146,6 @@ declare module 'pg-mvc-service' {
         constructor(errorId: string, message?: string);
     }
 
-    // export class TableModel {
-    //     protected readonly dbName: string;
-    //     get DbName(): string;
-    //     protected readonly tableName: string;
-    //     get TableName(): string;
-    //     protected readonly tableDescription: string;
-    //     get TableDescription(): string;
-    //     protected readonly comment: string;
-    //     get Comment(): string;
-    //     protected readonly columns: { [key: string]: TColumn };
-    //     get Columns(): { [key: string]: TColumn };
-    //     protected readonly references: Array<{table: string, columns: Array<{target: string, ref: string}>}>;
-    //     get References(): Array<{table: string, columns: Array<{target: string, ref: string}>}>;
-    //     public GetReferences(columnName: string): Array<{table: string, columns: Array<{target: string, ref: string}>}>;
-    //     get TableAlias(): string;
-    //     public IsOutputLog: boolean;
-    //     public SortKeyword: TSortKeyword;
-    //     public Offset: number;
-    //     public Limit: number;
-    //     public PageCount: number;
-    //     set OffsetPage(value: number);
-
-    //     constructor(client: Pool);
-    //     constructor(client: Pool, tableAlias: string);
-    //     constructor(client: PoolClient);
-    //     constructor(client: PoolClient, tableAlias: string);
-
-    //     public select(): void;
-    //     public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*'): void;
-    //     public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', model: TableModel): void;
-    //     public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', keyFormat: TKeyFormat): void;
-    //     public select(columls: Array<string | {name: string, alias?: string, func?: TAggregateFuncType}> | '*', model: TableModel, keyFormat: TKeyFormat): void;
-    //     public select(expression: string, alias: string): void;
-
-    //     public join(joinType: 'left' | 'inner', joinModel: TableModel, conditions: Array<TNestedCondition>): void;
-
-    //     public where(expression: string): void;
-    //     public where(conditions: Array<TNestedCondition>): 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>;
-    //     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 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>;
-
-    //     protected readonly errorMessages: Record<TColumnType | 'length' | 'null' | 'notInput', string>
-    //     protected throwValidationError(code: string, message: string): never;
-    //     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: {[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>;
-
-    //     public executeSelect<T = {[key: string]: any}>(): Promise<Array<T>>;
-    //     public executeSelectWithCount<T = any>(): Promise<{ datas: Array<T>, count: number, lastPage: number}>;
-
-    //     protected executeQuery(param1: string, vars?: Array<any>) : Promise<any>;
-    //     protected executeQuery(param1: TQuery) : Promise<any>;
-
-    //     public orderBy(column: string | TColumnInfo, sortKeyword: TSortKeyword): void;
-    //     public orderByList(column: string | TColumnInfo, list: Array<string | number | boolean | null>, sortKeyword: TSortKeyword): void;
-    //     public orderBySentence(query: string, sortKeyword: TSortKeyword): void;
-
-    //     public groupBy(column: string | TColumnInfo): void;
-
-    //     get ValidateClient(): ValidateClient;
-    // }
-
     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

package/package.json

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

package/src/models/ExpressionClient.ts

@@ -0,0 +1,61 @@
+import { TableModel } from "./TableModel";
+import { TColumnInfo } from "./Type";
+
+export default class ExpressionClient {
+    private model: TableModel;
+    constructor(model: TableModel) {
+        this.model = model;
+    }
+
+    public toSqlStringValue(value: any): string {
+        if (typeof value === 'string' || typeof value === 'number') {
+            return `"${value}"`;
+        }
+
+        throw new Error('Please enter a value of type string or number.');
+    }
+
+    public toSqlNumberValue(value: any): string {
+        if (typeof value === 'number') {
+            return value.toString();
+        } else if (typeof value === 'string') {
+            if (value.trim() !== "" || isNaN(Number(value)) === false) {
+                return value;
+            }
+        }
+
+        throw new Error('Please enter a value of type number or a string of half-width digits.');
+    }
+
+    public createCaseFromObject(column: string | TColumnInfo, obj: {[key: string | number]: string | number | boolean | null}, elseValue: string | number | boolean | null): string {
+        const columnInfo = typeof column === 'string' ? this.model.getColumn(column) : column.model.getColumn(column.name);
+        if (columnInfo.type !== 'string' && columnInfo.type !== 'integer') {
+            throw new Error('This method cannot be used for columns other than integer, real, or string.');
+        }
+
+        const whenExpression = Object.entries(obj).map(([key, value]) => {
+            let expression = `WHEN ${columnInfo.expression} = `;
+            // 今は文字列と数値だけだが、他のも対応しないといけないかも
+            if (columnInfo.type === 'string') {
+                expression += this.toSqlStringValue(key);
+            } else {
+                expression += this.toSqlNumberValue(key);
+            }
+            expression += ` THEN `;
+
+            if (value === null) {
+                expression += 'null';
+            } else if (typeof value === 'string') {
+                expression += `"${value}"`;
+            } else if (typeof value === 'boolean') {
+                expression += `${value}`;                
+            } else {
+                expression += `${value}`;
+            }
+
+            return expression;
+        });
+
+        return `CASE ${whenExpression.join(' ')} END`;
+    }
+}

package/src/models/TableModel.ts

@@ -5,6 +5,7 @@ import SelectExpression from './SqlUtils/SelectExpression';
 import WhereExpression from './SqlUtils/WhereExpression';
 import ValidateClient from './ValidateClient';
 import { DbConflictException, UnprocessableException } from '../exceptions/Exception';
+import ExpressionClient from './ExpressionClient';
 
 export class TableModel {
 
@@ -122,6 +123,9 @@ export class TableModel {
     }
 
     private client: PoolClient | Pool;
+    get Client(): PoolClient | Pool {
+        return this.client;
+    }
     constructor(client: Pool);
     constructor(client: Pool, tableAlias: string);
     constructor(client: PoolClient);
@@ -757,4 +761,13 @@ export class TableModel {
 
         return this.validateClient;
     }
+
+    private expressionClient?: ExpressionClient;
+    get ExpressionClient(): ExpressionClient {
+        if (this.expressionClient === undefined) {
+            this.expressionClient = new ExpressionClient(this);
+        }
+
+        return this.expressionClient;
+    }
 }