@powfix/core-js 0.13.38 → 0.14.0

package/dist/src/services/time/TimeService.d.ts

@@ -1,39 +1,36 @@
-import EventEmitter3 from 'eventemitter3';
+import EventEmitter from 'eventemitter3';
 export declare enum TimeServiceStatus {
     STOPPED = 0,
     RUNNING = 1
 }
-export declare class TimeService {
+export declare class TimeService extends EventEmitter<TimeService.Event> {
     private static readonly DEFAULT_SYNC_INTERVAL;
-    protected status: TimeServiceStatus;
+    private static DEFAULT_CLIENT_TIME_PROVIDER;
+    private syncHandler?;
+    private syncInterval?;
+    private clientTimeProvider?;
+    private serverTimeProvider?;
     private offset?;
-    private option;
     private syncedAt?;
-    private emitter;
-    readonly on: <T extends TimeService.Event>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter3<TimeService.Event, any>;
-    readonly off: <T extends TimeService.Event>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean) => EventEmitter3<TimeService.Event, any>;
-    private readonly emit;
     static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset;
     constructor(option: TimeService.Option);
-    getOption(): TimeService.Option;
-    setOption(option: TimeService.Option): TimeService.Option;
     getOffset(defaultValue: TimeService.Offset): TimeService.Offset;
     getOffset(): TimeService.Offset | undefined;
     setOffset(offset: TimeService.Offset): TimeService.Offset;
     setOffset(offset: TimeService.Offset | undefined): TimeService.Offset;
     getSyncedAt(): TimeService.TimeStamp | undefined;
     private setSyncedAt;
-    getSyncInterval(): number | null;
+    getSyncInterval(): number;
     setSyncInterval(interval: TimeService.Option['syncInterval']): void;
+    getClientTimeProvider(): TimeService.ClientTimeProvider;
+    setClientTimeProvider(provider: TimeService.ClientTimeProvider): void;
     getClientTime(defaultValue?: TimeService.TimeStamp): TimeService.TimeStamp;
+    getServerTimeProvider(): TimeService.ServerTimeProvider | null | undefined;
+    setServerTimeProvider(provider: TimeService.ServerTimeProvider): void;
     getServerTime(): TimeService.TimeStamp | null;
     getTime(): number;
     private fetchServerNTPResult;
-    getStatus(): TimeServiceStatus;
-    start(): void;
-    stop(): void;
     sync(): Promise<TimeService.Offset | null>;
-    private syncHandler?;
     private startSync;
     private stopSync;
 }
@@ -52,9 +49,8 @@ export declare namespace TimeService {
     type ClientTimeProvider = () => TimeStamp;
     type ServerTimeProvider = (t1: NTPResult['t1']) => (ServerNTPResult | null) | (Promise<ServerNTPResult | null>);
     interface Option {
-        autoStart?: boolean;
-        syncInterval?: number | null | undefined;
-        clientTimeProvider?: ClientTimeProvider | undefined;
-        serverTimeProvider?: ServerTimeProvider | undefined;
+        syncInterval?: number;
+        clientTimeProvider?: ClientTimeProvider;
+        serverTimeProvider?: ServerTimeProvider;
     }
 }

package/dist/src/services/time/TimeService.js

@@ -20,34 +20,24 @@ var TimeServiceStatus;
     TimeServiceStatus[TimeServiceStatus["STOPPED"] = 0] = "STOPPED";
     TimeServiceStatus[TimeServiceStatus["RUNNING"] = 1] = "RUNNING";
 })(TimeServiceStatus || (exports.TimeServiceStatus = TimeServiceStatus = {}));
-class TimeService {
+class TimeService extends eventemitter3_1.default {
+    static DEFAULT_CLIENT_TIME_PROVIDER() {
+        return Date.now();
+    }
     static calculateNTPResultOffset(ntpResult) {
         const { t1, t2, t3, t4 } = ntpResult;
         return ((t2 - t1) + (t3 - t4)) / 2;
     }
     constructor(option) {
-        this.status = TimeServiceStatus.STOPPED;
-        // Emitter
-        this.emitter = new eventemitter3_1.default();
-        this.on = this.emitter.on.bind(this.emitter);
-        this.off = this.emitter.off.bind(this.emitter);
-        this.emit = this.emitter.emit.bind(this.emitter);
-        this.option = option;
-        if (option.autoStart) {
-            this.start();
-        }
+        super();
+        // Options
+        this.syncInterval = option.syncInterval;
+        this.clientTimeProvider = option.clientTimeProvider;
+        this.serverTimeProvider = option.serverTimeProvider;
         // Bind
         this.sync = this.sync.bind(this);
-        this.start = this.start.bind(this);
-        this.stop = this.stop.bind(this);
         this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
     }
-    getOption() {
-        return this.option;
-    }
-    setOption(option) {
-        return this.option = option;
-    }
     getOffset(defaultValue) {
         if (this.offset !== undefined) {
             return this.offset;
@@ -70,41 +60,37 @@ class TimeService {
         return syncedAt;
     }
     getSyncInterval() {
-        if (this.option.syncInterval === undefined) {
-            // If option is undefined using default value
-            return TimeService.DEFAULT_SYNC_INTERVAL;
-        }
-        if (this.option.syncInterval === null || this.option.syncInterval === -1) {
-            // If option is null, do not sync automatically
-            return null;
-        }
-        return this.option.syncInterval;
+        var _a;
+        return (_a = this.syncInterval) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_SYNC_INTERVAL;
     }
     setSyncInterval(interval) {
-        this.option.syncInterval = interval;
+        this.syncInterval = interval;
         // Emit
         this.emit('SYNC_INTERVAL_CHANGED', interval);
-        if (this.status === TimeServiceStatus.RUNNING) {
-            if (this.syncHandler !== undefined) {
-                this.stopSync();
-                this.startSync();
-            }
+        if (this.syncHandler !== undefined) {
+            this.stopSync();
+            this.startSync();
         }
     }
+    getClientTimeProvider() {
+        var _a;
+        return (_a = this.clientTimeProvider) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_CLIENT_TIME_PROVIDER;
+    }
+    setClientTimeProvider(provider) {
+        this.clientTimeProvider = provider;
+    }
     getClientTime(defaultValue = Date.now()) {
-        try {
-            if (typeof this.option.clientTimeProvider === 'function') {
-                return this.option.clientTimeProvider();
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return defaultValue;
+        return this.getClientTimeProvider()();
+    }
+    getServerTimeProvider() {
+        return this.serverTimeProvider;
+    }
+    setServerTimeProvider(provider) {
+        this.serverTimeProvider = provider;
     }
     getServerTime() {
         const offset = this.getOffset();
-        if (offset === undefined) {
+        if (offset == null) {
             return null;
         }
         const clientTime = this.getClientTime();
@@ -116,8 +102,9 @@ class TimeService {
     fetchServerNTPResult(t1) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (typeof this.option.serverTimeProvider === 'function') {
-                    return yield this.option.serverTimeProvider(t1);
+                const provider = this.getServerTimeProvider();
+                if (typeof provider === 'function') {
+                    return yield provider(t1);
                 }
             }
             catch (e) {
@@ -126,35 +113,6 @@ class TimeService {
             return null;
         });
     }
-    getStatus() {
-        return this.status;
-    }
-    start() {
-        if (this.status !== TimeServiceStatus.STOPPED) {
-            console.warn(LOG_TAG, 'service is not stopped');
-            return;
-        }
-        // Change status
-        this.status = TimeServiceStatus.RUNNING;
-        // Sync immediately
-        this.sync().finally(() => { });
-        // Start sync
-        this.startSync();
-    }
-    stop() {
-        if (this.status !== TimeServiceStatus.RUNNING) {
-            console.warn(LOG_TAG, 'service is not running');
-            return;
-        }
-        // Change status
-        this.status = TimeServiceStatus.RUNNING;
-        // Stop sync
-        this.stopSync();
-        // Reset offset
-        this.setOffset(undefined);
-        // Reset synced at
-        this.setSyncedAt(undefined);
-    }
     sync() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -205,25 +163,25 @@ class TimeService {
         });
     }
     startSync() {
-        if (this.syncHandler !== undefined) {
-            console.warn('sync handler is not undefined', this.syncHandler);
+        if (this.syncHandler != null) {
+            console.warn('sync is already started');
             return;
         }
         const syncInterval = this.getSyncInterval();
-        if (syncInterval === null) {
+        if (syncInterval == null || syncInterval <= 0) {
+            console.warn('sync is not started', 'syncInterval', syncInterval);
             return;
         }
-        this.syncHandler = setInterval(this.sync, syncInterval);
+        this.syncHandler = setInterval(this.sync.bind(this), syncInterval);
     }
     ;
     stopSync() {
-        if (this.syncHandler === undefined) {
-            return;
+        if (this.syncHandler != null) {
+            clearInterval(this.syncHandler);
+            this.syncHandler = undefined;
         }
-        clearInterval(this.syncHandler);
-        this.syncHandler = undefined;
     }
     ;
 }
 exports.TimeService = TimeService;
-TimeService.DEFAULT_SYNC_INTERVAL = 60000;
+TimeService.DEFAULT_SYNC_INTERVAL = 60 * 1000;

package/dist/src/utils/nodejs/index.d.ts

@@ -1,2 +1,2 @@
 export * from './HookUtils';
-export * from './SequelizeUtils';
+export { SequelizeUtils } from './sequelize-utils';

package/dist/src/utils/nodejs/index.js

@@ -14,5 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeUtils = void 0;
 __exportStar(require("./HookUtils"), exports);
-__exportStar(require("./SequelizeUtils"), exports);
+var sequelize_utils_1 = require("./sequelize-utils");
+Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return sequelize_utils_1.SequelizeUtils; } });

package/dist/src/utils/nodejs/sequelize-utils/SequelizeUtils.d.ts

@@ -0,0 +1,9 @@
+import { ModelAttributeColumnOptions, WhereOptions } from "sequelize";
+import { Model, NonKnownUuidStringKeys, UuidColumnOptionsBase, UuidColumnOptionsForModel } from "./types";
+export declare class SequelizeUtils {
+    static decimal2Number(value: any): number | null | undefined;
+    static buildPrimaryUuidColumn: () => Partial<ModelAttributeColumnOptions>;
+    static buildUuidColumn<T extends Model, AdditionalKeys extends NonKnownUuidStringKeys<T> = never>(options: UuidColumnOptionsForModel<T, AdditionalKeys>): Partial<ModelAttributeColumnOptions>;
+    static buildUuidColumn(options: UuidColumnOptionsBase): Partial<ModelAttributeColumnOptions>;
+    static getNullableArrayFilter<T = undefined>(arr: (null | any)[]): WhereOptions<T>;
+}

package/dist/src/utils/nodejs/{SequelizeUtils.js → sequelize-utils/SequelizeUtils.js}

@@ -13,8 +13,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeUtils = void 0;
 const sequelize_1 = require("sequelize");
-const UuidUtils_1 = require("../UuidUtils");
-const constants_1 = require("../../constants");
+const UuidUtils_1 = require("../../UuidUtils");
+const constants_1 = require("../../../constants");
 class SequelizeUtils {
     static decimal2Number(value) {
         if (value === null || value === undefined) {
@@ -26,7 +26,7 @@ class SequelizeUtils {
         }
         return parsed;
     }
-    static getUuidColumn(options) {
+    static buildUuidColumn(options) {
         const { columnName } = options, overrideOptions = __rest(options, ["columnName"]);
         if (overrideOptions.allowNull) {
             return Object.assign({ type: "binary(16)", get() {
@@ -66,16 +66,10 @@ class SequelizeUtils {
     }
 }
 exports.SequelizeUtils = SequelizeUtils;
-SequelizeUtils.getPrimaryUuidColumn = () => ({
-    type: "binary(16)",
+SequelizeUtils.buildPrimaryUuidColumn = () => (Object.assign({}, SequelizeUtils.buildUuidColumn({
+    columnName: "uuid",
     allowNull: false,
     primaryKey: true,
     unique: true,
     defaultValue: () => UuidUtils_1.UuidUtils.toBuffer(UuidUtils_1.UuidUtils.v4()),
-    get() {
-        return UuidUtils_1.UuidUtils.toString(this.getDataValue("uuid"));
-    },
-    set(uuid) {
-        this.setDataValue("uuid", UuidUtils_1.UuidUtils.toBuffer(uuid));
-    }
-});
+})));

package/dist/src/utils/nodejs/sequelize-utils/index.d.ts

@@ -0,0 +1 @@
+export { SequelizeUtils } from './SequelizeUtils';

package/dist/src/utils/nodejs/sequelize-utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeUtils = void 0;
+var SequelizeUtils_1 = require("./SequelizeUtils");
+Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return SequelizeUtils_1.SequelizeUtils; } });

package/dist/src/utils/nodejs/sequelize-utils/types.d.ts

@@ -0,0 +1,16 @@
+import { ModelAttributeColumnOptions } from "sequelize";
+export type Model = Record<string, any> | undefined;
+export type ExtractUuidKeys<T extends Model> = {
+    [Property in keyof T]: Property extends `${string}Uuid` | 'uuid' ? Property : never;
+}[keyof T];
+export type ExtractStringKeys<T extends Model> = {
+    [Property in keyof T]: string extends T[Property] ? Property : never;
+}[keyof T];
+export type ConcreteUuidKeys<T extends Model> = ExtractUuidKeys<T>;
+export type NonKnownUuidStringKeys<T extends Model> = Exclude<ExtractStringKeys<T>, ConcreteUuidKeys<T>> & string;
+export interface UuidColumnOptionsBase extends Omit<ModelAttributeColumnOptions, 'type'> {
+    columnName: string;
+}
+export interface UuidColumnOptionsForModel<T extends Model, AdditionalKeys extends string> extends Omit<ModelAttributeColumnOptions, 'type'> {
+    columnName: ConcreteUuidKeys<T> | AdditionalKeys;
+}

package/dist/src/utils/nodejs/sequelize-utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.13.38",
+  "version": "0.14.0",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,
@@ -43,6 +43,7 @@
     "typescript": "5.8.3"
   },
   "peerDependencies": {
-    "moment": ">=2.0.0"
+    "moment": ">=2.0.0",
+    "eventemitter3": ">=5"
   }
 }

package/dist/src/utils/nodejs/SequelizeUtils.d.ts

@@ -1,23 +0,0 @@
-import { ModelAttributeColumnOptions, WhereOptions } from "sequelize";
-type Model = Record<string, any> | undefined;
-type GetIncludeKeyPatterns<T extends Model> = T extends {
-    _id: string;
-} ? `${string}Uuid` | 'uuid' : `${string}Uuid`;
-type ExtractUuidKeys<T extends Model> = {
-    [Property in keyof T]: Property extends GetIncludeKeyPatterns<T> ? Property : never;
-}[keyof T];
-type ConcreteUuidKeys<T extends Record<string, any>> = ExtractUuidKeys<T>;
-interface UuidColumnOptionsBase extends Omit<ModelAttributeColumnOptions, 'type'> {
-    columnName: string;
-}
-interface UuidColumnOptionsForModel<T extends Record<string, any>> extends Omit<ModelAttributeColumnOptions, 'type'> {
-    columnName: ConcreteUuidKeys<T>;
-}
-export declare class SequelizeUtils {
-    static decimal2Number(value: any): number | null | undefined;
-    static getPrimaryUuidColumn: () => Partial<ModelAttributeColumnOptions>;
-    static getUuidColumn<T extends Record<string, any>>(options: UuidColumnOptionsForModel<T>): Partial<ModelAttributeColumnOptions>;
-    static getUuidColumn(options: UuidColumnOptionsBase): Partial<ModelAttributeColumnOptions>;
-    static getNullableArrayFilter<T = undefined>(arr: (null | any)[]): WhereOptions<T>;
-}
-export {};