gyomu 0.1.0

package/lib/net/ftp.d.ts

@@ -0,0 +1,19 @@
+import ftp from 'basic-ftp';
+import { NetworkError } from '../errors';
+import { FileTransportInfo } from '../fileModel';
+import { Failure, Result } from '../result';
+import { RemoteConnection } from './remoteConnection';
+export declare class Ftp {
+    #private;
+    constructor(connectionConfig: RemoteConnection);
+    client: ftp.Client;
+    get connected(): boolean;
+    download(transportInformation: FileTransportInfo): Promise<import("../result").Success<boolean> | Failure<NetworkError>>;
+    upload(transportInformation: FileTransportInfo): Promise<import("../result").Success<boolean> | Failure<NetworkError>>;
+    getFileInfo(transportInformation: FileTransportInfo): Promise<Failure<NetworkError> | import("../result").Success<{
+        size: number;
+        date: Date;
+    }>>;
+    listFiles(transportInformation: FileTransportInfo): Promise<Failure<NetworkError> | import("../result").Success<string[]>>;
+    close(): Result<boolean, NetworkError>;
+}

package/lib/net/ftp.js

@@ -0,0 +1,160 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _Ftp_instances, _Ftp_connectionInformation, _Ftp_init;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ftp = void 0;
+const basic_ftp_1 = __importDefault(require("basic-ftp"));
+const errors_1 = require("../errors");
+const result_1 = require("../result");
+const path_1 = __importDefault(require("path"));
+class Ftp {
+    constructor(connectionConfig) {
+        _Ftp_instances.add(this);
+        _Ftp_connectionInformation.set(this, void 0);
+        __classPrivateFieldSet(this, _Ftp_connectionInformation, connectionConfig, "f");
+        this.client = new basic_ftp_1.default.Client();
+    }
+    get connected() {
+        return !this.client.closed;
+    }
+    download(transportInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Ftp_instances, "m", _Ftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            try {
+                if (!transportInformation.isSourceDirectory)
+                    yield this.client.downloadTo(transportInformation.destinationFullName, transportInformation.sourceFullName.replace(path_1.default.sep, '/'));
+                else
+                    yield this.client.downloadToDir(transportInformation.destinationPath, transportInformation.sourceFolderName.replace(path_1.default.sep, '/'));
+                return (0, result_1.success)(true);
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to do ftp download', err));
+            }
+        });
+    }
+    upload(transportInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Ftp_instances, "m", _Ftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            try {
+                if (!transportInformation.isSourceDirectory)
+                    yield this.client.uploadFrom(transportInformation.sourceFullName, transportInformation.destinationFullName.replace(path_1.default.sep, '/'));
+                else
+                    yield this.client.uploadFromDir(transportInformation.sourceFullName, transportInformation.destinationFullName.replace(path_1.default.sep, '/'));
+                return (0, result_1.success)(true);
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to do ftp upload', err));
+            }
+        });
+    }
+    getFileInfo(transportInformation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Ftp_instances, "m", _Ftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            const fullPath = (_a = transportInformation.sourceFullName) !== null && _a !== void 0 ? _a : ''.replace(path_1.default.sep, '/');
+            try {
+                const size = yield this.client.size(fullPath);
+                const lastModifiedDate = yield this.client.lastMod(fullPath);
+                return (0, result_1.success)({ size: size, date: lastModifiedDate });
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to get ftp file information', err));
+            }
+        });
+    }
+    listFiles(transportInformation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Ftp_instances, "m", _Ftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            const fullPath = (_a = transportInformation.sourceFullName) !== null && _a !== void 0 ? _a : ''.replace(path_1.default.sep, '/');
+            try {
+                const fileInfoList = yield this.client.list(fullPath);
+                return (0, result_1.success)(fileInfoList.map((f) => f.name));
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to retrieve ftp folders', err));
+            }
+        });
+    }
+    close() {
+        if (!this.connected)
+            return (0, result_1.success)(true);
+        try {
+            this.client.close();
+            return (0, result_1.success)(true);
+        }
+        catch (err) {
+            return new result_1.Failure(new errors_1.NetworkError('Fail to close ftp connection', err));
+        }
+    }
+}
+exports.Ftp = Ftp;
+_Ftp_connectionInformation = new WeakMap(), _Ftp_instances = new WeakSet(), _Ftp_init = function _Ftp_init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.client.ftp.verbose = true;
+        try {
+            const ftpResponse = yield this.client.access({
+                host: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").serverURL,
+                user: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").userId,
+                password: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").password,
+                port: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").port,
+                secure: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").sslEnabled
+                    ? __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").sslImplicit
+                        ? 'implicit'
+                        : true
+                    : false,
+                secureOptions: !__classPrivateFieldGet(this, _Ftp_connectionInformation, "f").sslEnabled
+                    ? undefined
+                    : {
+                        host: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").serverURL,
+                        port: __classPrivateFieldGet(this, _Ftp_connectionInformation, "f").port,
+                        checkServerIdentity: (hostname, cert) => {
+                            return undefined;
+                        },
+                    },
+            });
+            return (0, result_1.success)(true);
+        }
+        catch (err) {
+            return new result_1.Failure(new errors_1.NetworkError('Fail to do ftp conneciton', err));
+        }
+    });
+};

package/lib/net/remoteConnection.d.ts

@@ -0,0 +1,11 @@
+export declare class RemoteConnection {
+    serverURL: string;
+    port: number;
+    userId: string;
+    password?: string;
+    privateKeyFilename?: string;
+    isPassive?: boolean;
+    sslEnabled?: boolean;
+    sslImplicit?: boolean;
+    setSsl(isImplicit: boolean): void;
+}

package/lib/net/remoteConnection.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteConnection = void 0;
+class RemoteConnection {
+    constructor() {
+        this.serverURL = '';
+        this.port = 21;
+        this.userId = '';
+    }
+    // setProxy(
+    //   proxyHost: string,
+    //   proxyPort: number,
+    //   proxyUser: string,
+    //   proxyPassword: string
+    // ) {
+    //   this.proxyHost = proxyHost;
+    //   this.proxyPort = proxyPort;
+    //   this.proxyUserID = proxyUser;
+    //   this.proxyPassword = proxyPassword;
+    // }
+    setSsl(isImplicit) {
+        this.sslEnabled = true;
+        this.sslImplicit = isImplicit;
+    }
+}
+exports.RemoteConnection = RemoteConnection;

package/lib/net/sftp.d.ts

@@ -0,0 +1,19 @@
+import sftp from 'ssh2-sftp-client';
+import { RemoteConnection } from './remoteConnection';
+import { Failure } from '../result';
+import { NetworkError } from '../errors';
+import { FileTransportInfo } from '../fileModel';
+export declare class Sftp {
+    #private;
+    constructor(connectionConfig: RemoteConnection);
+    client: sftp;
+    connected: boolean;
+    download(transportInformation: FileTransportInfo): Promise<import("../result").Success<boolean> | Failure<NetworkError>>;
+    upload(transportInformation: FileTransportInfo): Promise<import("../result").Success<boolean> | Failure<NetworkError>>;
+    getFileInfo(transportInformation: FileTransportInfo): Promise<Failure<NetworkError> | import("../result").Success<{
+        size: number;
+        date: Date;
+    }>>;
+    listFiles(transportInformation: FileTransportInfo): Promise<Failure<NetworkError> | import("../result").Success<string[]>>;
+    close(): Promise<import("../result").Success<boolean> | Failure<NetworkError>>;
+}

package/lib/net/sftp.js

@@ -0,0 +1,155 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _Sftp_instances, _Sftp_config, _Sftp_init;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sftp = void 0;
+const ssh2_sftp_client_1 = __importDefault(require("ssh2-sftp-client"));
+const fs_1 = __importDefault(require("fs"));
+const result_1 = require("../result");
+const errors_1 = require("../errors");
+const path_1 = __importDefault(require("path"));
+class Sftp {
+    constructor(connectionConfig) {
+        _Sftp_instances.add(this);
+        _Sftp_config.set(this, void 0);
+        __classPrivateFieldSet(this, _Sftp_config, connectionConfig, "f");
+        this.client = new ssh2_sftp_client_1.default();
+        this.connected = false;
+    }
+    download(transportInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Sftp_instances, "m", _Sftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            try {
+                if (!transportInformation.isSourceDirectory)
+                    yield this.client.get(transportInformation.sourceFullName.replace(path_1.default.sep, '/'), transportInformation.destinationFullName);
+                else
+                    yield this.client.downloadDir(transportInformation.sourceFolderName.replace(path_1.default.sep, '/'), transportInformation.destinationPath);
+                return (0, result_1.success)(true);
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to do sftp download', err));
+            }
+        });
+    }
+    upload(transportInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Sftp_instances, "m", _Sftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            try {
+                if (!transportInformation.isSourceDirectory)
+                    yield this.client.put(transportInformation.sourceFullName, transportInformation.destinationFullName.replace(path_1.default.sep, '/'));
+                else
+                    yield this.client.uploadDir(transportInformation.sourceFullName, transportInformation.destinationFullName.replace(path_1.default.sep, '/'));
+                return (0, result_1.success)(true);
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to do sftp upload', err));
+            }
+        });
+    }
+    getFileInfo(transportInformation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Sftp_instances, "m", _Sftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            const fullPath = (_a = transportInformation.sourceFullName) !== null && _a !== void 0 ? _a : ''.replace(path_1.default.sep, '/');
+            try {
+                const stat = yield this.client.stat(fullPath);
+                return (0, result_1.success)({ size: stat.size, date: new Date(stat.modifyTime) });
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to get sftp file information', err));
+            }
+        });
+    }
+    listFiles(transportInformation) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                const result = yield __classPrivateFieldGet(this, _Sftp_instances, "m", _Sftp_init).call(this);
+                if (result.isFailure())
+                    return result;
+            }
+            const fullPath = (_a = transportInformation.sourceFullName) !== null && _a !== void 0 ? _a : ''.replace(path_1.default.sep, '/');
+            try {
+                const fileInfoList = yield this.client.list(fullPath);
+                return (0, result_1.success)(fileInfoList.map((f) => f.name));
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to retrieve sftp folders', err));
+            }
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected)
+                return (0, result_1.success)(true);
+            try {
+                yield this.client.end();
+                this.connected = false;
+                return (0, result_1.success)(true);
+            }
+            catch (err) {
+                return new result_1.Failure(new errors_1.NetworkError('Fail to close sftp connection', err));
+            }
+        });
+    }
+}
+exports.Sftp = Sftp;
+_Sftp_config = new WeakMap(), _Sftp_instances = new WeakSet(), _Sftp_init = function _Sftp_init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const ftpResponse = yield this.client.connect({
+                host: __classPrivateFieldGet(this, _Sftp_config, "f").serverURL,
+                username: __classPrivateFieldGet(this, _Sftp_config, "f").userId,
+                port: __classPrivateFieldGet(this, _Sftp_config, "f").port,
+                password: !!__classPrivateFieldGet(this, _Sftp_config, "f").privateKeyFilename
+                    ? undefined
+                    : __classPrivateFieldGet(this, _Sftp_config, "f").password,
+                privateKey: !!__classPrivateFieldGet(this, _Sftp_config, "f").privateKeyFilename
+                    ? fs_1.default.readFileSync(__classPrivateFieldGet(this, _Sftp_config, "f").privateKeyFilename)
+                    : undefined,
+                passphrase: !!__classPrivateFieldGet(this, _Sftp_config, "f").privateKeyFilename
+                    ? __classPrivateFieldGet(this, _Sftp_config, "f").password
+                    : undefined,
+            });
+            this.connected = true;
+            return (0, result_1.success)(true);
+        }
+        catch (err) {
+            return new result_1.Failure(new errors_1.NetworkError('Fail to do ftp conneciton', err));
+        }
+    });
+};

package/lib/numberOperation.d.ts

@@ -0,0 +1,3 @@
+export declare const toHalfAdjust: (targetNumber: number, digit: number) => number;
+export declare const toRoundUp: (targetNumber: number, digit: number) => number;
+export declare const toRoundDown: (targetNumber: number, digit: number) => number;

package/lib/numberOperation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoundDown = exports.toRoundUp = exports.toHalfAdjust = void 0;
+const toHalfAdjust = (targetNumber, digit) => {
+    if (digit === 0)
+        return Math.round(targetNumber);
+    const adjust = Math.pow(10, digit);
+    return Math.round(targetNumber * adjust) / adjust;
+};
+exports.toHalfAdjust = toHalfAdjust;
+const toRoundUp = (targetNumber, digit) => {
+    if (digit === 0)
+        return Math.ceil(targetNumber);
+    const adjust = Math.pow(10, digit);
+    return Math.ceil(targetNumber * adjust) / adjust;
+};
+exports.toRoundUp = toRoundUp;
+const toRoundDown = (targetNumber, digit) => {
+    if (digit === 0)
+        return Math.floor(targetNumber);
+    const adjust = Math.pow(10, digit);
+    return Math.floor(targetNumber * adjust) / adjust;
+};
+exports.toRoundDown = toRoundDown;

package/lib/parameter.d.ts

@@ -0,0 +1,14 @@
+import { DBError } from './errors';
+import { PromiseResult } from './result';
+import { User } from './user';
+declare type ParameterType = string | number | boolean;
+export declare class ParameterAccess {
+    #private;
+    static keyExists(key: string): PromiseResult<boolean, DBError>;
+    static getKey(key: string, user?: User): string;
+    static value(key: string, user?: User, targetDate?: Date): PromiseResult<string, DBError>;
+    static booleanValue(key: string, user?: User, targetDate?: Date): PromiseResult<boolean, DBError>;
+    static numberValue(key: string, user?: User, targetDate?: Date): PromiseResult<number, DBError>;
+    static setValue<T extends ParameterType>(key: string, item: T, user?: User): PromiseResult<boolean, DBError>;
+}
+export {};