@relq/orm 0.1.3 → 0.1.5

package/dist/esm/mysql/condition/fulltext-condition-builder.js

@@ -0,0 +1,55 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlFulltextConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    match(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'natural' }
+        });
+        return this.parent;
+    }
+    matchBoolean(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'boolean' }
+        });
+        return this.parent;
+    }
+    matchExpansion(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'expansion' }
+        });
+        return this.parent;
+    }
+}
+export function buildMysqlFulltextConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'fulltext_match': {
+            const { query, mode } = values;
+            const columns = column.includes(',')
+                ? column.split(',').map(c => mysqlFormat.ident(c.trim())).join(', ')
+                : mysqlFormat.ident(column);
+            const escapedQuery = mysqlFormat.literal(query);
+            switch (mode) {
+                case 'natural':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} IN NATURAL LANGUAGE MODE)`;
+                case 'boolean':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} IN BOOLEAN MODE)`;
+                case 'expansion':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} WITH QUERY EXPANSION)`;
+                default:
+                    return `MATCH(${columns}) AGAINST(${escapedQuery})`;
+            }
+        }
+        default:
+            return '';
+    }
+}

package/dist/esm/mysql/condition/index.js

@@ -0,0 +1,4 @@
+export { MysqlConditionCollector, buildMysqlConditionSQL, buildMysqlConditionsSQL } from "./condition-collector.js";
+export { MysqlJsonConditionCollector, buildMysqlJsonConditionSQL } from "./json-condition-builder.js";
+export { createMysqlJsonColumnProxy, buildMysqlJsonProxySQL } from "./json-path-proxy.js";
+export { MysqlFulltextConditionCollector, buildMysqlFulltextConditionSQL } from "./fulltext-condition-builder.js";

package/dist/esm/mysql/condition/json-condition-builder.js

@@ -0,0 +1,136 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlJsonConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'json_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    notContains(column, value) {
+        this.parent.conditions.push({
+            method: 'json_not_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    overlaps(column, value) {
+        this.parent.conditions.push({
+            method: 'json_overlaps',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    extract(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractEqual(column, path, value) {
+        return this.extract(column, path, value);
+    }
+    extractGreaterThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract_gt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractLessThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract_lt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractIn(column, path, values) {
+        this.parent.conditions.push({
+            method: 'json_extract_in',
+            column,
+            values: { path, inValues: values }
+        });
+        return this.parent;
+    }
+    hasKey(column, key) {
+        this.parent.conditions.push({
+            method: 'json_has_key',
+            column,
+            values: key
+        });
+        return this.parent;
+    }
+    length(column, length) {
+        this.parent.conditions.push({
+            method: 'json_length',
+            column,
+            values: length
+        });
+        return this.parent;
+    }
+    typeIs(column, path, jsonType) {
+        this.parent.conditions.push({
+            method: 'json_type_is',
+            column,
+            values: { path, jsonType }
+        });
+        return this.parent;
+    }
+}
+export function buildMysqlJsonConditionSQL(condition) {
+    const { method, column, values } = condition;
+    const col = column ? mysqlFormat.ident(column) : '';
+    switch (method) {
+        case 'json_contains':
+            return `JSON_CONTAINS(${col}, ${mysqlFormat.literal(JSON.stringify(values))})`;
+        case 'json_not_contains':
+            return `NOT JSON_CONTAINS(${col}, ${mysqlFormat.literal(JSON.stringify(values))})`;
+        case 'json_overlaps':
+            return `JSON_OVERLAPS(${col}, ${mysqlFormat.literal(JSON.stringify(values))})`;
+        case 'json_extract': {
+            const { path, value } = values;
+            if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+                return `JSON_EXTRACT(${col}, ${mysqlFormat.literal(path)}) = ${mysqlFormat.literal(value)}`;
+            }
+            return `JSON_UNQUOTE(JSON_EXTRACT(${col}, ${mysqlFormat.literal(path)})) = ${mysqlFormat.literal(value)}`;
+        }
+        case 'json_extract_gt': {
+            const { path: gtPath, value: gtValue } = values;
+            return `JSON_EXTRACT(${col}, ${mysqlFormat.literal(gtPath)}) > ${mysqlFormat.literal(gtValue)}`;
+        }
+        case 'json_extract_lt': {
+            const { path: ltPath, value: ltValue } = values;
+            return `JSON_EXTRACT(${col}, ${mysqlFormat.literal(ltPath)}) < ${mysqlFormat.literal(ltValue)}`;
+        }
+        case 'json_extract_in': {
+            const { path: inPath, inValues } = values;
+            const formattedValues = inValues.map(v => mysqlFormat.literal(v)).join(', ');
+            return `JSON_UNQUOTE(JSON_EXTRACT(${col}, ${mysqlFormat.literal(inPath)})) IN (${formattedValues})`;
+        }
+        case 'json_has_key': {
+            const key = values;
+            return `JSON_EXTRACT(${col}, ${mysqlFormat.literal(`$.${key}`)}) IS NOT NULL`;
+        }
+        case 'json_length': {
+            const length = values;
+            return `JSON_LENGTH(${col}) = ${length}`;
+        }
+        case 'json_type_is': {
+            const { path, jsonType } = values;
+            return `JSON_TYPE(JSON_EXTRACT(${col}, ${mysqlFormat.literal(path)})) = ${mysqlFormat.literal(jsonType)}`;
+        }
+        default:
+            return '';
+    }
+}