ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/mysql/index.js

@@ -11,6 +11,7 @@ exports.createMySQLDialect = createMySQLDialect;
 const promise_1 = __importDefault(require("mysql2/promise"));
 const prorm_1 = require("../../prorm");
 const operators_1 = require("../../operators");
+const operators_2 = require("../../operators");
 /**
  * Default retry options for connection
  */
@@ -1183,25 +1184,35 @@ class MySQLDialect {
         await this.query(sql);
     }
     // ============================================================================
-    // Schema methods (MySQL uses databases instead of schemas, these are not supported)
+    // Schema methods
+    //
+    // In MySQL, SCHEMA is a synonym for DATABASE (`CREATE SCHEMA` == `CREATE
+    // DATABASE`, `DROP SCHEMA` == `DROP DATABASE`, and schemas are enumerated via
+    // `SHOW DATABASES`). These are implemented so callers never have to drop to
+    // raw SQL just to manage databases.
     // ============================================================================
     /**
-     * Create a schema - Not supported by MySQL (use CREATE DATABASE instead)
+     * Create a schema (database). `CREATE SCHEMA` is a MySQL synonym for
+     * `CREATE DATABASE`; emitted with `IF NOT EXISTS` for idempotency.
      */
-    async createSchema(_schema) {
-        throw new Error('Not supported by MySQL: schemas are called databases. Use CREATE DATABASE instead.');
+    async createSchema(schema) {
+        await this.query(`CREATE SCHEMA IF NOT EXISTS ${this.escapeId(schema)}`);
     }
     /**
-     * Drop a schema - Not supported by MySQL (use DROP DATABASE instead)
+     * Drop a schema (database). `DROP SCHEMA` is a MySQL synonym for
+     * `DROP DATABASE`. MySQL has no `CASCADE` on `DROP DATABASE` (dropping a
+     * database always removes all of its tables), so `options.cascade` is
+     * accepted for interface parity but has no additional effect.
      */
-    async dropSchema(_schema, _options) {
-        throw new Error('Not supported by MySQL: schemas are called databases. Use DROP DATABASE instead.');
+    async dropSchema(schema, options) {
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        await this.query(`DROP SCHEMA ${ifExists}${this.escapeId(schema)}`);
     }
     /**
-     * Show all schemas - Not supported by MySQL (use SHOW DATABASES instead)
+     * Show all schemas (databases) via `SHOW DATABASES`.
      */
     async showAllSchemas() {
-        throw new Error('Not supported by MySQL: schemas are called databases. Use SHOW DATABASES instead.');
+        return this.listSchemas();
     }
     /**
      * List all schemas (databases) in MySQL
@@ -1661,11 +1672,59 @@ class MySQLDialect {
     async changeOwner(_newOwner, _tableName) {
         throw new Error('changeOwner is not supported in MySQL');
     }
-    async addConstraint(_tableName, _options) {
-        throw new Error('addConstraint is not supported in MySQL');
+    /**
+     * Build an `ALTER TABLE ... ADD [CONSTRAINT name] ...` statement for the
+     * simple {@link addConstraint} form (synchronous, no execution). MySQL fully
+     * supports adding PRIMARY KEY / UNIQUE / FOREIGN KEY / CHECK constraints via
+     * ALTER TABLE, so this is a first-class capability — no raw SQL required.
+     */
+    buildAddConstraintSql(tableName, options) {
+        const namePart = options.name ? `CONSTRAINT ${this.escapeId(options.name)} ` : '';
+        const fieldList = (options.fields || []).map((f) => this.escapeId(f)).join(', ');
+        const prefix = `ALTER TABLE ${this.escapeId(tableName)} ADD ${namePart}`;
+        switch (options.type) {
+            case 'PRIMARY KEY':
+                if (!fieldList) {
+                    throw new Error('PRIMARY KEY constraint requires fields');
+                }
+                return `${prefix}PRIMARY KEY (${fieldList})`;
+            case 'UNIQUE':
+                if (!fieldList) {
+                    throw new Error('UNIQUE constraint requires fields');
+                }
+                return `${prefix}UNIQUE (${fieldList})`;
+            case 'CHECK':
+                if (!options.check) {
+                    throw new Error('CHECK constraint requires a check expression');
+                }
+                return `${prefix}CHECK (${options.check})`;
+            case 'FOREIGN KEY': {
+                if (!fieldList || !options.references) {
+                    throw new Error('FOREIGN KEY constraint requires fields and a `references` target');
+                }
+                const refFields = options.references.fields.map((f) => this.escapeId(f)).join(', ');
+                return `${prefix}FOREIGN KEY (${fieldList}) REFERENCES ${this.escapeId(options.references.table)} (${refFields})`;
+            }
+            default:
+                throw new Error(`Unknown constraint type: ${String(options.type)}`);
+        }
+    }
+    /**
+     * Add a constraint to an existing table via `ALTER TABLE ... ADD CONSTRAINT`.
+     * MySQL supports this natively (the previous "not supported" error was wrong
+     * and forced callers into raw SQL).
+     */
+    async addConstraint(tableName, options) {
+        await this.query(this.buildAddConstraintSql(tableName, options));
     }
-    async removeConstraint(_tableName, _constraintName) {
-        throw new Error('removeConstraint is not supported in MySQL');
+    /**
+     * Drop a named constraint via `ALTER TABLE ... DROP CONSTRAINT` (MySQL
+     * 8.0.16+ accepts the generic form for CHECK/FK/PK/UNIQUE constraints). For
+     * kind-specific drops on older servers use {@link dropConstraint} with the
+     * appropriate clause.
+     */
+    async removeConstraint(tableName, constraintName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} DROP CONSTRAINT ${this.escapeId(constraintName)}`);
     }
     async createSecurityPolicy(_policyName, _tableName, _options) {
         throw new Error('Security policies are not supported in MySQL');
@@ -2617,7 +2676,7 @@ class MySQLDialect {
             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];
             }
@@ -2668,7 +2727,7 @@ class MySQLDialect {
                             normalizedObj[`$json:${symDesc.substring(5)}`] = rawValueObj[sym];
                             continue;
                         }
-                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        const strKey = (0, operators_2.operatorToWhereKey)(sym);
                         if (strKey)
                             normalizedObj[strKey] = rawValueObj[sym];
                     }
@@ -3034,6 +3093,15 @@ class MySQLDialect {
     /**
      * 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';
     }
@@ -3077,7 +3145,7 @@ class MySQLDialect {
                         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
@@ -3101,7 +3169,7 @@ class MySQLDialect {
                     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
@@ -3142,7 +3210,7 @@ class MySQLDialect {
                     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);
@@ -3163,7 +3231,7 @@ class MySQLDialect {
                 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('.')) {