ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/mariadb/index.js

@@ -11,46 +11,29 @@
  * - CONNECT storage engine types
  * - Enhanced ON DELETE/UPDATE constraints
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MariaDBRowFormats = exports.MariaDBConnectTypes = exports.MariaDBStorageEngines = exports.MariaDBTransaction = exports.MariaDBDialect = void 0;
 exports.createMariaDBDialect = createMariaDBDialect;
-const mariadb = __importStar(require("mariadb"));
+const operators_1 = require("../../operators");
+// Lazily-loaded `mariadb` driver. Required only when a connection is opened,
+// so importing this ORM never loads the mariadb driver.
+let mariadbModule = null;
+function loadMariaDb() {
+    if (!mariadbModule) {
+        try {
+            mariadbModule = require('mariadb');
+        }
+        catch (err) {
+            throw new Error("The 'mariadb' package is required to use the MariaDB dialect but could not be loaded. " +
+                'Install it with `npm install mariadb`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return mariadbModule;
+}
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
-const operators_1 = require("../../operators");
+const operators_2 = require("../../operators");
 /**
  * MariaDB dialect class that implements the Dialect interface
  * Extends MySQL compatibility with MariaDB-specific features
@@ -75,7 +58,7 @@ class MariaDBDialect {
      */
     async connect() {
         try {
-            this.pool = mariadb.createPool({
+            this.pool = loadMariaDb().createPool({
                 host: this.config.host,
                 port: this.config.port,
                 user: this.config.username,
@@ -431,6 +414,105 @@ class MariaDBDialect {
             values,
         };
     }
+    assertDynamicColumnType(type) {
+        const normalized = type.trim().toUpperCase();
+        if (!MariaDBDialect.DYNAMIC_COLUMN_TYPES.has(normalized)) {
+            throw new Error(`Unsupported MariaDB dynamic-column type '${type}'. Expected one of: ${[...MariaDBDialect.DYNAMIC_COLUMN_TYPES].join(', ')}.`);
+        }
+        return normalized;
+    }
+    /**
+     * Build a `COLUMN_CREATE(key, value [AS type], ...)` expression that packs a
+     * set of named values into a MariaDB dynamic-column BLOB.
+     *
+     * @param pairs Ordered key -> value (or `{ value, type }`) map. `type` is an
+     *   optional MariaDB dynamic-column type applied as `value AS type`.
+     * @returns `{ sql, values }` with `?` placeholders for every key and value.
+     *
+     * @example
+     * buildColumnCreate({ color: 'blue', size: { value: 42, type: 'INTEGER' } })
+     * // COLUMN_CREATE(?, ?, ?, ? AS INTEGER)  values: ['color','blue','size',42]
+     */
+    buildColumnCreate(pairs) {
+        const parts = [];
+        const values = [];
+        for (const [key, raw] of Object.entries(pairs)) {
+            const entry = raw !== null && typeof raw === 'object' && 'value' in raw
+                ? raw
+                : { value: raw, type: undefined };
+            parts.push('?');
+            values.push(key);
+            if (entry.type) {
+                parts.push(`? AS ${this.assertDynamicColumnType(entry.type)}`);
+            }
+            else {
+                parts.push('?');
+            }
+            values.push(entry.value);
+        }
+        return { sql: `COLUMN_CREATE(${parts.join(', ')})`, values };
+    }
+    /**
+     * Build a `COLUMN_ADD(column, key, value [AS type], ...)` expression that
+     * inserts/updates named values in an existing dynamic-column BLOB.
+     */
+    buildColumnAdd(column, pairs) {
+        const inner = this.buildColumnCreate(pairs);
+        // COLUMN_ADD has the same tail grammar as COLUMN_CREATE, just prefixed by
+        // the target column reference.
+        const tail = inner.sql.slice('COLUMN_CREATE('.length);
+        return { sql: `COLUMN_ADD(${this.escapeId(column)}, ${tail}`, values: inner.values };
+    }
+    /**
+     * Build a `COLUMN_GET(column, key AS type)` expression that extracts a single
+     * value from a dynamic-column BLOB, cast to the requested MariaDB type
+     * (defaults to `CHAR`).
+     */
+    buildColumnGet(column, key, type = 'CHAR') {
+        return {
+            sql: `COLUMN_GET(${this.escapeId(column)}, ? AS ${this.assertDynamicColumnType(type)})`,
+            values: [key],
+        };
+    }
+    /**
+     * Build a `COLUMN_DELETE(column, key, ...)` expression that removes one or
+     * more keys from a dynamic-column BLOB.
+     */
+    buildColumnDelete(column, ...keys) {
+        const placeholders = keys.map(() => '?').join(', ');
+        return {
+            sql: `COLUMN_DELETE(${this.escapeId(column)}, ${placeholders})`,
+            values: keys,
+        };
+    }
+    /**
+     * Build a `COLUMN_EXISTS(column, key)` predicate that returns 1 if the given
+     * key exists in the dynamic-column BLOB.
+     */
+    buildColumnExists(column, key) {
+        return { sql: `COLUMN_EXISTS(${this.escapeId(column)}, ?)`, values: [key] };
+    }
+    /**
+     * Build a `COLUMN_LIST(column)` expression returning a comma-separated list
+     * of the keys present in a dynamic-column BLOB.
+     */
+    buildColumnList(column) {
+        return `COLUMN_LIST(${this.escapeId(column)})`;
+    }
+    /**
+     * Build a `COLUMN_CHECK(column)` predicate that validates a dynamic-column
+     * BLOB is well-formed.
+     */
+    buildColumnCheck(column) {
+        return `COLUMN_CHECK(${this.escapeId(column)})`;
+    }
+    /**
+     * Build a `COLUMN_JSON(column)` expression that serializes an entire
+     * dynamic-column BLOB to a JSON object.
+     */
+    buildColumnJson(column) {
+        return `COLUMN_JSON(${this.escapeId(column)})`;
+    }
     /**
      * Escape a string for SQL
      */
@@ -2106,7 +2188,7 @@ class MariaDBDialect {
             const topSymbols = Object.getOwnPropertySymbols(rawCond);
             const normalizedCond = { ...rawCond };
             for (const sym of topSymbols) {
-                const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                const strKey = (0, operators_2.operatorToWhereKey)(sym);
                 if (strKey)
                     normalizedCond[strKey] = rawCond[sym];
             }
@@ -2148,7 +2230,7 @@ class MariaDBDialect {
                         ...rawValueObj,
                     };
                     for (const sym of symbolKeys) {
-                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        const strKey = (0, operators_2.operatorToWhereKey)(sym);
                         if (strKey)
                             normalizedObj[strKey] = rawValueObj[sym];
                     }
@@ -2512,6 +2594,15 @@ class MariaDBDialect {
     /**
      * Check if a value is a literal expression (literal('sql'))
      */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    literalSql(expr) {
+        return (0, operators_1.expandLiteralBindings)(expr, (v) => this.escape(v));
+    }
     isLiteralExpression(value) {
         return value !== null && typeof value === 'object' && value.__type === 'literal';
     }
@@ -2555,7 +2646,7 @@ class MariaDBDialect {
                         sql = this.escapeId(expr.col);
                     }
                     else if (this.isLiteralExpression(expr)) {
-                        sql = expr.sql;
+                        sql = this.literalSql(expr);
                     }
                     else if (typeof expr === 'string') {
                         // Check if it's a column reference or literal SQL
@@ -2579,7 +2670,7 @@ class MariaDBDialect {
                     return this.escapeId(attr.col);
                 }
                 else if (this.isLiteralExpression(attr)) {
-                    return attr.sql;
+                    return this.literalSql(attr);
                 }
                 else if (typeof attr === 'string') {
                     // Plain column name
@@ -2623,7 +2714,7 @@ class MariaDBDialect {
                     sql = this.escapeId(expr.col);
                 }
                 else if (this.isLiteralExpression(expr)) {
-                    sql = expr.sql;
+                    sql = this.literalSql(expr);
                 }
                 else if (typeof expr === 'string') {
                     sql = this.escapeId(expr);
@@ -2644,7 +2735,7 @@ class MariaDBDialect {
                 return this.escapeId(field.col);
             }
             else if (this.isLiteralExpression(field)) {
-                return field.sql;
+                return this.literalSql(field);
             }
             else if (typeof field === 'string') {
                 if (field.includes('.')) {
@@ -2836,7 +2927,26 @@ class MariaDBDialect {
                 distinctClause = 'DISTINCT ';
             }
         }
-        let sql = `${cteSql}SELECT ${distinctClause}${selectSql} FROM ${this.escapeId(options.tableName)}`;
+        // MariaDB optimizer hints. Two independent forms are supported (either or
+        // both may be requested, without any raw SQL):
+        //   - `hints: ['MAX_EXECUTION_TIME(1000)', 'BKA(t1)']` -> emitted as a
+        //     `/*+ ... */` optimizer-hint comment immediately after SELECT.
+        //   - `straightJoin: true` -> emits the `STRAIGHT_JOIN` modifier, which
+        //     forces the optimizer to join tables in the FROM/JOIN order given.
+        // See https://mariadb.com/kb/en/optimizer-hints/ .
+        let hintClause = '';
+        const rawHints = options.hints;
+        if (rawHints) {
+            const hintList = Array.isArray(rawHints) ? rawHints : [rawHints];
+            const cleaned = hintList
+                .map((h) => String(h).trim())
+                .filter((h) => h.length > 0);
+            if (cleaned.length > 0) {
+                hintClause = `/*+ ${cleaned.join(' ')} */ `;
+            }
+        }
+        const straightJoinClause = options.straightJoin ? 'STRAIGHT_JOIN ' : '';
+        let sql = `${cteSql}SELECT ${hintClause}${straightJoinClause}${distinctClause}${selectSql} FROM ${this.escapeId(options.tableName)}`;
         // MariaDB 10.3+ system-versioned (temporal) table querying:
         // `FOR SYSTEM_TIME AS OF ...` / `BETWEEN ... AND ...` / `FROM ... TO ...`
         // / `ALL`. This is a MariaDB/SQL:2011 feature MySQL lacks entirely.
@@ -3505,6 +3615,34 @@ class MariaDBDialect {
     }
 }
 exports.MariaDBDialect = MariaDBDialect;
+// ---------------------------------------------------------------------------
+// Dynamic columns (MariaDB-only; MySQL has no equivalent)
+//
+// MariaDB stores a set of dynamically-typed key/value pairs inside a single
+// BLOB column via the COLUMN_* function family. These builders let callers
+// create, read, mutate, and introspect dynamic columns entirely through the
+// dialect API instead of hand-writing COLUMN_CREATE/COLUMN_GET SQL.
+// See https://mariadb.com/kb/en/dynamic-columns/ .
+// ---------------------------------------------------------------------------
+/**
+ * The MariaDB value types accepted by COLUMN_CREATE / COLUMN_ADD /
+ * COLUMN_GET. These map to the `AS <type>` cast used by COLUMN_GET and the
+ * inline `<value> AS <type>` annotation used by COLUMN_CREATE/COLUMN_ADD.
+ */
+MariaDBDialect.DYNAMIC_COLUMN_TYPES = new Set([
+    'BINARY',
+    'CHAR',
+    'DATE',
+    'DATETIME',
+    'DECIMAL',
+    'DOUBLE',
+    'INTEGER',
+    'SIGNED',
+    'SIGNED INTEGER',
+    'TIME',
+    'UNSIGNED',
+    'UNSIGNED INTEGER',
+]);
 /**
  * MariaDB-specific transaction class
  */