@fluyappgocore/commons-backend 1.0.208 → 1.0.210

package/build/helpers/dialectHelper.d.ts

@@ -0,0 +1,34 @@
+export declare class DialectHelper {
+    private dialect;
+    constructor(dialectOrSequelize: string | {
+        getDialect(): string;
+    });
+    get isPostgres(): boolean;
+    get isMssql(): boolean;
+    get isMysql(): boolean;
+    get dialectName(): string;
+    now(): string;
+    bool(val: boolean): string;
+    qi(name: string): string;
+    jsonType(): string;
+    autoIncrement(): string;
+    textArrayType(): string;
+    ilike(): string;
+    booleanType(): string;
+    textType(): string;
+    jsonValue(column: string, path: string): string;
+    jsonQuery(column: string, path: string): string;
+    jsonSet(column: string, path: string, value: string): string;
+    upsertIgnore(table: string, columns: string[], values: string[][], conflictColumn: string): string;
+    upsertUpdate(table: string, columns: string[], values: string[], conflictColumn: string, updateColumns: string[]): string;
+    returning(columns?: string[]): string;
+    limit(n: number): string;
+    limitClause(n: number): string;
+    timestampDefault(): string;
+    createIndexIfNotExists(table: string, indexName: string, columns: string[], unique?: boolean): string;
+    concat(...parts: string[]): string;
+    toTimestamp(value: string): string;
+}
+export declare function createDialectHelper(dialectOrSequelize: string | {
+    getDialect(): string;
+}): DialectHelper;

package/build/helpers/dialectHelper.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDialectHelper = exports.DialectHelper = void 0;
+var DialectHelper = /** @class */ (function () {
+    function DialectHelper(dialectOrSequelize) {
+        this.dialect = typeof dialectOrSequelize === 'string'
+            ? dialectOrSequelize
+            : dialectOrSequelize.getDialect();
+    }
+    Object.defineProperty(DialectHelper.prototype, "isPostgres", {
+        get: function () { return this.dialect === 'postgres'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "isMssql", {
+        get: function () { return this.dialect === 'mssql'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "isMysql", {
+        get: function () { return this.dialect === 'mysql' || this.dialect === 'mariadb'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "dialectName", {
+        get: function () { return this.dialect; },
+        enumerable: false,
+        configurable: true
+    });
+    DialectHelper.prototype.now = function () {
+        if (this.isMssql)
+            return 'GETDATE()';
+        return 'NOW()'; // postgres + mysql
+    };
+    DialectHelper.prototype.bool = function (val) {
+        if (this.isMssql)
+            return val ? '1' : '0';
+        if (this.isMysql)
+            return val ? '1' : '0';
+        return val ? 'true' : 'false'; // postgres
+    };
+    DialectHelper.prototype.qi = function (name) {
+        if (this.isMssql)
+            return "[" + name + "]";
+        if (this.isMysql)
+            return "`" + name + "`";
+        return "\"" + name + "\""; // postgres
+    };
+    DialectHelper.prototype.jsonType = function () {
+        if (this.isMssql)
+            return 'NVARCHAR(MAX)';
+        if (this.isMysql)
+            return 'JSON';
+        return 'JSONB'; // postgres
+    };
+    DialectHelper.prototype.autoIncrement = function () {
+        if (this.isMssql)
+            return 'INT IDENTITY(1,1)';
+        if (this.isMysql)
+            return 'INT AUTO_INCREMENT';
+        return 'SERIAL'; // postgres
+    };
+    DialectHelper.prototype.textArrayType = function () {
+        if (this.isPostgres)
+            return 'TEXT[]';
+        return 'NVARCHAR(MAX)'; // mssql + mysql (store as JSON string)
+    };
+    DialectHelper.prototype.ilike = function () {
+        return this.isPostgres ? 'ILIKE' : 'LIKE'; // mssql + mysql use LIKE
+    };
+    DialectHelper.prototype.booleanType = function () {
+        if (this.isMssql)
+            return 'BIT';
+        if (this.isMysql)
+            return 'TINYINT(1)';
+        return 'BOOLEAN'; // postgres
+    };
+    DialectHelper.prototype.textType = function () {
+        if (this.isMssql)
+            return 'NVARCHAR(MAX)';
+        if (this.isMysql)
+            return 'LONGTEXT';
+        return 'TEXT'; // postgres
+    };
+    DialectHelper.prototype.jsonValue = function (column, path) {
+        if (this.isMssql)
+            return "JSON_VALUE(" + this.qi(column) + ", '$." + path + "')";
+        if (this.isMysql)
+            return "JSON_UNQUOTE(JSON_EXTRACT(" + this.qi(column) + ", '$." + path + "'))";
+        return this.qi(column) + "->>'" + path + "'"; // postgres
+    };
+    DialectHelper.prototype.jsonQuery = function (column, path) {
+        if (this.isMssql)
+            return "JSON_QUERY(" + this.qi(column) + ", '$." + path + "')";
+        if (this.isMysql)
+            return "JSON_EXTRACT(" + this.qi(column) + ", '$." + path + "')";
+        return this.qi(column) + "->'" + path + "'"; // postgres
+    };
+    DialectHelper.prototype.jsonSet = function (column, path, value) {
+        if (this.isMssql)
+            return "JSON_MODIFY(" + this.qi(column) + ", '$." + path + "', " + value + ")";
+        if (this.isMysql)
+            return "JSON_SET(" + this.qi(column) + ", '$." + path + "', " + value + ")";
+        return "jsonb_set(" + this.qi(column) + ", '{" + path.replace(/\./g, ',') + "}', " + value + ")"; // postgres
+    };
+    DialectHelper.prototype.upsertIgnore = function (table, columns, values, conflictColumn) {
+        var _this = this;
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        if (this.isMssql) {
+            return values.map(function (row) {
+                var conflictIdx = columns.indexOf(conflictColumn);
+                var whereClause = _this.qi(conflictColumn) + " = " + row[conflictIdx];
+                var valList = row.join(', ');
+                return "IF NOT EXISTS (SELECT 1 FROM " + _this.qi(table) + " WHERE " + whereClause + ")\n  INSERT INTO " + _this.qi(table) + " (" + colList + ") VALUES (" + valList + ");";
+            }).join('\n');
+        }
+        if (this.isMysql) {
+            var valRows_1 = values.map(function (row) { return "(" + row.join(', ') + ")"; }).join(',\n      ');
+            return "INSERT IGNORE INTO " + this.qi(table) + " (" + colList + ") VALUES\n      " + valRows_1 + ";";
+        }
+        // postgres
+        var valRows = values.map(function (row) { return "(" + row.join(', ') + ")"; }).join(',\n      ');
+        return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES\n      " + valRows + "\n    ON CONFLICT (" + this.qi(conflictColumn) + ") DO NOTHING;";
+    };
+    DialectHelper.prototype.upsertUpdate = function (table, columns, values, conflictColumn, updateColumns) {
+        var _this = this;
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        var valList = values.join(', ');
+        if (this.isMssql) {
+            var updateSet_1 = updateColumns.map(function (c) {
+                var idx = columns.indexOf(c);
+                return _this.qi(c) + " = " + values[idx];
+            }).join(', ');
+            return "MERGE " + this.qi(table) + " AS target\nUSING (SELECT " + values.map(function (v, i) { return v + " AS " + _this.qi(columns[i]); }).join(', ') + ") AS source\nON target." + this.qi(conflictColumn) + " = source." + this.qi(conflictColumn) + "\nWHEN MATCHED THEN UPDATE SET " + updateSet_1 + "\nWHEN NOT MATCHED THEN INSERT (" + colList + ") VALUES (" + valList + ");";
+        }
+        if (this.isMysql) {
+            var updateSet_2 = updateColumns.map(function (c) { return _this.qi(c) + " = VALUES(" + _this.qi(c) + ")"; }).join(', ');
+            return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES (" + valList + ")\nON DUPLICATE KEY UPDATE " + updateSet_2 + ";";
+        }
+        // postgres
+        var updateSet = updateColumns.map(function (c) { return _this.qi(c) + " = EXCLUDED." + _this.qi(c); }).join(', ');
+        return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES (" + valList + ")\nON CONFLICT (" + this.qi(conflictColumn) + ") DO UPDATE SET " + updateSet + ";";
+    };
+    DialectHelper.prototype.returning = function (columns) {
+        var _this = this;
+        if (columns === void 0) { columns = ['*']; }
+        if (this.isMssql || this.isMysql)
+            return '';
+        return "RETURNING " + columns.map(function (c) { return _this.qi(c); }).join(', '); // postgres only
+    };
+    DialectHelper.prototype.limit = function (n) {
+        return this.isMssql ? "TOP " + n : ''; // postgres + mysql use LIMIT clause
+    };
+    DialectHelper.prototype.limitClause = function (n) {
+        if (this.isMssql)
+            return '';
+        return "LIMIT " + n; // postgres + mysql
+    };
+    DialectHelper.prototype.timestampDefault = function () {
+        if (this.isMssql)
+            return 'DEFAULT GETDATE()';
+        return 'DEFAULT NOW()'; // postgres + mysql
+    };
+    // Create index with IF NOT EXISTS support
+    DialectHelper.prototype.createIndexIfNotExists = function (table, indexName, columns, unique) {
+        var _this = this;
+        if (unique === void 0) { unique = false; }
+        var uniqueStr = unique ? 'UNIQUE ' : '';
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        if (this.isMssql) {
+            return "IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '" + indexName + "')\nCREATE " + uniqueStr + "INDEX " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+        }
+        if (this.isMysql) {
+            // MySQL doesn't support IF NOT EXISTS for CREATE INDEX, use procedure
+            return "CREATE " + uniqueStr + "INDEX " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+        }
+        // postgres
+        return "CREATE " + uniqueStr + "INDEX IF NOT EXISTS " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+    };
+    // Concatenation
+    DialectHelper.prototype.concat = function () {
+        var parts = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            parts[_i] = arguments[_i];
+        }
+        if (this.isMssql)
+            return parts.join(' + ');
+        if (this.isMysql)
+            return "CONCAT(" + parts.join(', ') + ")";
+        return parts.join(' || '); // postgres
+    };
+    // String to timestamp
+    DialectHelper.prototype.toTimestamp = function (value) {
+        if (this.isMssql)
+            return "CAST(" + value + " AS DATETIME2)";
+        if (this.isMysql)
+            return "CAST(" + value + " AS DATETIME)";
+        return value + "::TIMESTAMP"; // postgres
+    };
+    return DialectHelper;
+}());
+exports.DialectHelper = DialectHelper;
+function createDialectHelper(dialectOrSequelize) {
+    return new DialectHelper(dialectOrSequelize);
+}
+exports.createDialectHelper = createDialectHelper;

package/build/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export { DialectHelper, createDialectHelper } from './dialectHelper';
+export { getMultiDialectGlobs } from './multiDialectMigrator';

package/build/helpers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultiDialectGlobs = exports.createDialectHelper = exports.DialectHelper = void 0;
+var dialectHelper_1 = require("./dialectHelper");
+Object.defineProperty(exports, "DialectHelper", { enumerable: true, get: function () { return dialectHelper_1.DialectHelper; } });
+Object.defineProperty(exports, "createDialectHelper", { enumerable: true, get: function () { return dialectHelper_1.createDialectHelper; } });
+var multiDialectMigrator_1 = require("./multiDialectMigrator");
+Object.defineProperty(exports, "getMultiDialectGlobs", { enumerable: true, get: function () { return multiDialectMigrator_1.getMultiDialectGlobs; } });

package/build/helpers/multiDialectMigrator.d.ts

@@ -0,0 +1,15 @@
+interface MigratorConfig {
+    migrationsPath: string;
+    dialect: string;
+    serviceName: string;
+}
+/**
+ * Returns the glob patterns for multi-dialect migrations.
+ * If common/ or {dialect}/ folders exist, returns those paths.
+ * Otherwise falls back to flat migrations/*.{ts,js} (backward compatible).
+ */
+export declare function getMultiDialectGlobs(config: MigratorConfig): {
+    globs: string[];
+    isMultiDialect: boolean;
+};
+export {};

package/build/helpers/multiDialectMigrator.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultiDialectGlobs = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+/**
+ * Returns the glob patterns for multi-dialect migrations.
+ * If common/ or {dialect}/ folders exist, returns those paths.
+ * Otherwise falls back to flat migrations/*.{ts,js} (backward compatible).
+ */
+function getMultiDialectGlobs(config) {
+    var migrationsPath = config.migrationsPath, dialect = config.dialect, serviceName = config.serviceName;
+    var commonDir = path_1.default.join(migrationsPath, 'common');
+    var dialectDir = path_1.default.join(migrationsPath, dialect);
+    var hasCommon = fs_1.default.existsSync(commonDir);
+    var hasDialect = fs_1.default.existsSync(dialectDir);
+    if (hasCommon || hasDialect) {
+        var globs = [];
+        if (hasCommon)
+            globs.push(path_1.default.join(commonDir, '*.{ts,js}'));
+        if (hasDialect)
+            globs.push(path_1.default.join(dialectDir, '*.{ts,js}'));
+        console.log("[" + serviceName + "] Multi-dialect migrations: common/" + (hasCommon ? '✓' : '✗') + " " + dialect + "/" + (hasDialect ? '✓' : '✗'));
+        return { globs: globs, isMultiDialect: true };
+    }
+    console.log("[" + serviceName + "] Legacy flat migrations");
+    return { globs: [path_1.default.join(migrationsPath, '*.{ts,js}')], isMultiDialect: false };
+}
+exports.getMultiDialectGlobs = getMultiDialectGlobs;

package/build/index.d.ts

@@ -5,6 +5,7 @@ export * from "./middlewares";
 export * from "./events";
 export * from "./dtos";
 export * from "./lib";
+export * from "./helpers";
 export { BacklogManager } from './classes/BacklogManager';
 export { BacklogMonitor } from './classes/BacklogMonitor';
 export { Listener } from './events/baseListener';

package/build/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./middlewares"), exports);
 __exportStar(require("./events"), exports);
 __exportStar(require("./dtos"), exports);
 __exportStar(require("./lib"), exports);
+__exportStar(require("./helpers"), exports);
 // Classes
 var BacklogManager_1 = require("./classes/BacklogManager");
 Object.defineProperty(exports, "BacklogManager", { enumerable: true, get: function () { return BacklogManager_1.BacklogManager; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluyappgocore/commons-backend",
-  "version": "1.0.208",
+  "version": "1.0.210",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",