gyomu 0.1.0

package/lib/parameter.js

@@ -0,0 +1,291 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _ParameterAccess_loadParameter;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterAccess = void 0;
+const date_fns_1 = require("date-fns");
+const dbsingleton_1 = __importDefault(require("./dbsingleton"));
+const errors_1 = require("./errors");
+const result_1 = require("./result");
+const dbutil_1 = require("./dbutil");
+class ParameterAccess {
+    static keyExists(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = yield __classPrivateFieldGet(this, _a, "m", _ParameterAccess_loadParameter).call(this, key);
+            if (values.isSuccess())
+                return (0, result_1.success)(values.value.length > 0);
+            return values;
+        });
+    }
+    static getKey(key, user) {
+        if (!!user)
+            return user.userId + '_' + key;
+        return key;
+    }
+    static value(key, user, targetDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemKey = this.getKey(key, user);
+            let itemValues = undefined;
+            let itemValue = '';
+            let errorCount = 0;
+            while (errorCount < 3) {
+                const result = yield __classPrivateFieldGet(this, _a, "m", _ParameterAccess_loadParameter).call(this, key);
+                if (result.isSuccess()) {
+                    itemValues = result.value;
+                    break;
+                }
+                errorCount++;
+                if (errorCount >= 3) {
+                    return result;
+                }
+            }
+            if (!itemValues || itemValues.length === 0) {
+                return (0, result_1.fail)('Unknown error on retrieving parameter', errors_1.DBError);
+            }
+            if (!!targetDate) {
+                const targetDateYYYYMMDD = (0, date_fns_1.format)(targetDate, 'yyyyMMdd');
+                const defaultRow = itemValues.find((v) => v.item_fromdate === '');
+                if (!!defaultRow) {
+                    itemValue = defaultRow.item_value;
+                }
+                const sortedArray = itemValues.sort((a, b) => {
+                    return a.item_fromdate > b.item_fromdate
+                        ? 1
+                        : a.item_fromdate === b.item_fromdate
+                            ? 0
+                            : -1;
+                });
+                for (var row of sortedArray) {
+                    //console.log(row.item_fromdate, targetDateYYYYMMDD);
+                    if (!row.item_value)
+                        continue;
+                    if (!row.item_fromdate || !row.item_fromdate.trim())
+                        itemValue = row.item_value;
+                    else if (row.item_fromdate === targetDateYYYYMMDD) {
+                        itemValue = row.item_value;
+                        break;
+                    }
+                    else if (targetDateYYYYMMDD > row.item_fromdate)
+                        itemValue = row.item_value;
+                    else
+                        break;
+                }
+            }
+            else {
+                itemValue = itemValues[0].item_value;
+            }
+            return (0, result_1.success)(itemValue);
+        });
+    }
+    static booleanValue(key, user, targetDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield ParameterAccess.value(key, user, targetDate);
+            if (result.isFailure())
+                return result;
+            const resultString = result.value;
+            return (0, result_1.success)(resultString === 'true');
+        });
+    }
+    static numberValue(key, user, targetDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield ParameterAccess.value(key, user, targetDate);
+            if (result.isFailure())
+                return result;
+            const resultString = result.value;
+            return (0, result_1.success)(+resultString);
+        });
+    }
+    // static async stringListValue(
+    //   key: string,
+    //   user?: User,
+    //   targetDate?: Date
+    // ): PromiseResult<Array<string>, DBError> {
+    //   const result = await ParameterAccess.value(key, user, targetDate);
+    //   if (result.isFailure()) return result;
+    //   const resultString = result.value;
+    //   const stringList = JSON.parse(resultString) as string[];
+    //   return success(stringList);
+    // }
+    // static async listValue<T>(
+    //   key: string,
+    //   user?: User,
+    //   targetDate?: Date
+    // ): PromiseResult<Array<T>, DBError> {
+    //   const result = await ParameterAccess.value(key, user, targetDate);
+    //   if (result.isFailure()) return result;
+    //   const resultString = result.value;
+    //   const list = JSON.parse(resultString) as Array<T>;
+    //   return success(list);
+    // }
+    // static async stringDictionaryValue(
+    //   key: string,
+    //   user?: User,
+    //   targetDate?: Date
+    // ): PromiseResult<{ [key: string]: string }, DBError> {
+    //   const result = await ParameterAccess.value(key, user, targetDate);
+    //   if (result.isFailure()) return result;
+    //   const resultString = result.value;
+    //   const dictionary = JSON.parse(resultString) as { [key: string]: string };
+    //   return success(dictionary);
+    // }
+    // static async dictionaryValue<T>(
+    //   key: string,
+    //   user?: User,
+    //   targetDate?: Date
+    // ): PromiseResult<{ [key: string]: T }, DBError> {
+    //   const result = await ParameterAccess.value(key, user, targetDate);
+    //   if (result.isFailure()) return result;
+    //   const resultString = result.value;
+    //   const dictionary = JSON.parse(resultString) as { [key: string]: T };
+    //   return success(dictionary);
+    // }
+    // static async base64EncodedValue(key: string): PromiseResult<string, DBError> {
+    //   const result = await ParameterAccess.value(key);
+    //   if (result.isFailure()) return result;
+    //   const resultString = result.value;
+    //   return success(base64String2String(resultString));
+    // }
+    static setValue(key, item, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemKey = this.getKey(key, user);
+            const keyExistResult = yield this.keyExists(itemKey);
+            const itemValue = item.toString();
+            if (keyExistResult.isFailure())
+                return keyExistResult;
+            //console.log('Key Check Done');
+            return yield (0, dbutil_1.genericDBFunction)(`setup gyomu_param_master for ${itemKey}`, (itemKey, itemValue) => __awaiter(this, void 0, void 0, function* () {
+                if (keyExistResult.value) {
+                    if (!itemValue) {
+                        //Delete Record
+                        yield dbsingleton_1.default.gyomu_param_master.delete({
+                            where: {
+                                item_key_item_fromdate: {
+                                    item_key: itemKey,
+                                    item_fromdate: '',
+                                },
+                            },
+                        });
+                    }
+                    else {
+                        //Update Record
+                        yield dbsingleton_1.default.gyomu_param_master.update({
+                            where: {
+                                item_key_item_fromdate: {
+                                    item_key: itemKey,
+                                    item_fromdate: '',
+                                },
+                            },
+                            data: { item_value: itemValue },
+                        });
+                    }
+                }
+                else {
+                    if (!!itemValue) {
+                        //Insert
+                        yield dbsingleton_1.default.gyomu_param_master.create({
+                            data: {
+                                item_key: itemKey,
+                                item_fromdate: '',
+                                item_value: itemValue,
+                            },
+                        });
+                    }
+                }
+                return (0, result_1.success)(true);
+            }), [itemKey, itemValue]);
+            // try {
+            //   if (keyExistResult.value) {
+            //     if (!itemValue) {
+            //       //Delete Record
+            //       await prisma.gyomu_param_master.delete({
+            //         where: {
+            //           item_key_item_fromdate: { item_key: itemKey, item_fromdate: '' },
+            //         },
+            //       });
+            //     } else {
+            //       //Update Record
+            //       await prisma.gyomu_param_master.update({
+            //         where: {
+            //           item_key_item_fromdate: { item_key: itemKey, item_fromdate: '' },
+            //         },
+            //         data: { item_value: itemValue },
+            //       });
+            //     }
+            //   } else {
+            //     if (!itemValue) {
+            //       //Insert
+            //       await prisma.gyomu_param_master.create({
+            //         data: {
+            //           item_key: itemKey,
+            //           item_fromdate: '',
+            //           item_value: itemValue,
+            //         },
+            //       });
+            //     }
+            //   }
+            //   return success(true);
+            // } catch (e) {
+            //   if (
+            //     e instanceof Prisma.PrismaClientKnownRequestError ||
+            //     e instanceof Prisma.PrismaClientUnknownRequestError ||
+            //     e instanceof Prisma.PrismaClientValidationError
+            //   ) {
+            //     return new Failure(
+            //       new DBError('Fail to set data on gyomu_param_master', e)
+            //     );
+            //   } else if (e instanceof Prisma.PrismaClientRustPanicError) {
+            //     throw new CriticalError(
+            //       'Critical error on Prisma. Need to terminate the application',
+            //       e
+            //     );
+            //   } else {
+            //     return new Failure(
+            //       new DBError(
+            //         'Unknown failure to set data on gyomu_param_master',
+            //         e as Error
+            //       )
+            //     );
+            //   }
+            //}
+        });
+    }
+}
+exports.ParameterAccess = ParameterAccess;
+_a = ParameterAccess, _ParameterAccess_loadParameter = function _ParameterAccess_loadParameter(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, dbutil_1.genericDBFunction)('load gyomu_param_master', (key) => __awaiter(this, void 0, void 0, function* () {
+            //console.log('loading');
+            const item_values = yield dbsingleton_1.default.gyomu_param_master.findMany({
+                where: { item_key: key },
+            });
+            //console.log('loaded');
+            return (0, result_1.success)(item_values);
+        }), [key]);
+        // try {
+        //   const item_values = await prisma.gyomu_param_master.findMany({
+        //     where: { item_key: key },
+        //   });
+        //   return success(item_values);
+        // } catch (err) {
+        //   return new Failure(
+        //     new DBError('Fail to load gyomu_param_master', err as Error)
+        //   );
+        // }
+    });
+};

package/lib/result.d.ts

@@ -0,0 +1,23 @@
+import { BaseError } from './errors';
+export declare type Result<T, E extends Error> = Success<T> | Failure<E>;
+export declare type PromiseResult<T, E extends Error> = Promise<Result<T, E>>;
+export declare class Success<T> {
+    readonly value: T;
+    constructor(value: T);
+    isSuccess(): this is Success<T>;
+    isFailure(): this is Failure<BaseError>;
+}
+export declare class Failure<E extends BaseError> {
+    readonly error: E;
+    constructor(error: E);
+    isSuccess(): this is Success<unknown>;
+    isFailure(): this is Failure<E>;
+}
+export declare function fail<E extends BaseError>(message: string, type: {
+    new (message: string): E;
+}): Failure<E>;
+export declare function success<T>(object: T): Success<T>;
+export declare function promiseSuccess<T, E extends BaseError>(val: T): PromiseResult<T, E>;
+export declare function promiseFail<T, E extends BaseError>(message: string, type: {
+    new (message: string): E;
+}): PromiseResult<T, E>;

package/lib/result.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseFail = exports.promiseSuccess = exports.success = exports.fail = exports.Failure = exports.Success = void 0;
+class Success {
+    constructor(value) {
+        this.value = value;
+    }
+    isSuccess() {
+        return true;
+    }
+    isFailure() {
+        return false;
+    }
+}
+exports.Success = Success;
+class Failure {
+    constructor(error) {
+        this.error = error;
+    }
+    isSuccess() {
+        return false;
+    }
+    isFailure() {
+        return true;
+    }
+}
+exports.Failure = Failure;
+function fail(message, type) {
+    return new Failure(new type(message));
+}
+exports.fail = fail;
+function success(object) {
+    return new Success(object);
+}
+exports.success = success;
+function promiseSuccess(val) {
+    return new Promise((resolve) => {
+        resolve(success(val));
+    });
+}
+exports.promiseSuccess = promiseSuccess;
+function promiseFail(message, type) {
+    return new Promise((resolve) => {
+        resolve(new Failure(new type(message)));
+    });
+}
+exports.promiseFail = promiseFail;

package/lib/timer.d.ts

@@ -0,0 +1,11 @@
+import { BaseError, TimeoutError } from './errors';
+import { PromiseResult, Result } from './result';
+/**
+ *
+ * @param pollingActionName
+ * explanation of this aciton during polling
+ * @returns
+ * Return success(true) when it's good result in polling. Otherwise return success(false)
+ * Return Failure with TimeoutError if there is any unexpected error
+ */
+export declare function polling<E extends BaseError>(pollingActionName: string, timeoutSeconds: number, intervalSeconds: number, timerFunc: (...args: any) => PromiseResult<boolean, E>, ...args: any): Promise<Result<boolean, TimeoutError>>;

package/lib/timer.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polling = void 0;
+const errors_1 = require("./errors");
+const result_1 = require("./result");
+/**
+ *
+ * @param pollingActionName
+ * explanation of this aciton during polling
+ * @returns
+ * Return success(true) when it's good result in polling. Otherwise return success(false)
+ * Return Failure with TimeoutError if there is any unexpected error
+ */
+function polling(pollingActionName, timeoutSeconds, intervalSeconds, timerFunc, ...args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeoutTime = new Date().getTime() + timeoutSeconds * 1000;
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield timerFunc(...args);
+                if (result.isFailure()) {
+                    return resolve(new result_1.Failure(new errors_1.TimeoutError(`Fail on polling: ${pollingActionName}`, result.error)));
+                }
+                else {
+                    if (result.value) {
+                        return resolve((0, result_1.success)(result.value));
+                    }
+                }
+                const timerId = yield setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    const result = yield timerFunc(...args);
+                    if (result.isFailure()) {
+                        clearInterval(timerId);
+                        return resolve(new result_1.Failure(new errors_1.TimeoutError(`Fail on polling: ${pollingActionName}`, result.error)));
+                    }
+                    else {
+                        if (result.value) {
+                            clearInterval(timerId);
+                            return resolve((0, result_1.success)(result.value));
+                        }
+                    }
+                    if (new Date().getTime() > timeoutTime) {
+                        //console.log('Timeout');
+                        clearInterval(timerId);
+                        return resolve((0, result_1.success)(false));
+                    }
+                }), intervalSeconds * 1000);
+            }
+            catch (e) {
+                reject(e);
+            }
+        }));
+    });
+}
+exports.polling = polling;

package/lib/user.d.ts

@@ -0,0 +1,11 @@
+export interface User {
+    isGroup: boolean;
+    isValid: boolean;
+    userId: string;
+    isEqual: (other: User) => boolean;
+    isInMember: (groupUser: User) => boolean;
+    region: string;
+}
+export declare class UserFactory {
+    static getCurrentUser: () => User;
+}

package/lib/user.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserFactory = void 0;
+class DummyUser {
+    constructor(uid) {
+        this.isGroup = false;
+        this.isValid = true;
+        this.isEqual = (other) => {
+            return this.userId === other.userId;
+        };
+        this.isInMember = (groupUser) => {
+            return false;
+        };
+        this.region = '';
+        this.userId = uid;
+    }
+}
+class UserFactory {
+}
+exports.UserFactory = UserFactory;
+UserFactory.getCurrentUser = () => {
+    return new DummyUser('testUid');
+};

package/lib/variable.d.ts

@@ -0,0 +1,11 @@
+import { DBError, ParseError } from './errors';
+import { PromiseResult } from './result';
+export declare class VariableTranslator {
+    #private;
+    __supportedMarkets: string[];
+    private constructor();
+    static getTranslator(market: string): PromiseResult<VariableTranslator, DBError>;
+    init(): Promise<void>;
+    parse(inputString: string, targetDate: Date): PromiseResult<string, ParseError>;
+    parseDate(keyword: string, targetDate: Date): PromiseResult<Date, ParseError>;
+}