@asla/yoursql 0.8.2 → 0.8.3

package/dist/sql_gen/sql_value/sql_value.js

@@ -0,0 +1,304 @@
+import { getObjectListKeys } from '../util.js';
+import { SqlStatementDataset } from '../select/query_chain_abstract.js';
+
+/**
+ * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
+ * @public
+ */
+class SqlRaw extends String {
+}
+/**
+ * SQL value 生成器
+ * @public
+ */
+class SqlValuesCreator {
+    static create(map) {
+        const obj = new this(map);
+        const fn = obj.toSqlStr.bind(obj);
+        Reflect.setPrototypeOf(fn, obj);
+        return fn;
+    }
+    /**
+     * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
+     * @example 输入 a'b'c , 返回 a''b''c.
+     */
+    static string(value) {
+        return "'" + value.replaceAll("'", "''") + "'";
+    }
+    /**
+     * @param map - 自定义对象转换
+     */
+    constructor(map) {
+        this._map = new Map(map);
+    }
+    setTransformer(type_map, encoder) {
+        if (typeof type_map === "function") {
+            if (encoder)
+                this._map.set(type_map, encoder);
+            else
+                this._map.delete(type_map);
+        }
+        else {
+            for (const [type, encoder] of type_map) {
+                if (typeof type === "function" && typeof encoder === "function") {
+                    this._map.set(type, encoder);
+                }
+            }
+        }
+    }
+    _map;
+    /**
+     * 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT
+     * ```ts
+     *  const v=SqlValuesCreator.create()
+     *  v() 和 v.toSqlStr() 是等价的
+     * ```
+     */
+    toSqlStr(value, assertJsType) {
+        if (value === null)
+            return "NULL";
+        else if (value === undefined)
+            return "DEFAULT";
+        let basicType = typeof value;
+        if (assertJsType) {
+            if (typeof assertJsType === "function") {
+                if (basicType !== "object")
+                    throw new AssertError("object", basicType);
+                let type = this._map.get(assertJsType);
+                if (!type) {
+                    if (assertJsType === Object)
+                        return this.defaultObject(value);
+                    throw new Error("类型不存在");
+                }
+                return type.call(this, value);
+            }
+            else if (basicType !== assertJsType) {
+                throw new AssertError(assertJsType, basicType);
+            }
+        }
+        switch (basicType) {
+            case "bigint":
+                return value.toString();
+            case "number":
+                return value.toString();
+            case "string":
+                return SqlValuesCreator.string(value);
+            case "boolean":
+                return value.toString();
+            case "object": {
+                if (value instanceof String)
+                    return value.toString();
+                const Class = this.getClassType(value);
+                if (Class)
+                    return this._map.get(Class).call(this, value);
+                return this.defaultObject(value);
+            }
+            case "undefined":
+                return "DEFAULT";
+            default:
+                //function、symbol
+                let type = typeof value;
+                throw new Error("不支持 " + type + " 类型");
+        }
+    }
+    /**
+     * @deprecated 已废弃
+     * 获取值对应的 SqlValueEncoder
+     */
+    getObjectType(value) {
+        for (const Class of this._map.keys()) {
+            if (value instanceof Class)
+                return this._map.get(Class);
+        }
+        return this.defaultObject;
+    }
+    /** 获取值对应已定义的类 */
+    getClassType(value) {
+        for (const Class of this._map.keys()) {
+            if (value instanceof Class)
+                return Class;
+        }
+    }
+    defaultObject(value) {
+        return SqlValuesCreator.string(JSON.stringify(value));
+    }
+    objectListToValuesList(objectList, keys_types, keepUndefinedKey) {
+        if (objectList.length <= 0)
+            throw new Error("objectList 不能是空数组");
+        let keys;
+        let asserts;
+        if (!keys_types) {
+            keys = Array.from(getObjectListKeys(objectList, keepUndefinedKey));
+            asserts = [];
+        }
+        else if (keys_types instanceof Array) {
+            keys = keys_types;
+            asserts = [];
+        }
+        else {
+            keys = Object.keys(keys_types);
+            asserts = initColumnAssert(keys, keys_types);
+        }
+        let str = "(" + this._internalObjectToValues(objectList[0], keys, asserts) + ")";
+        let i = 1;
+        let j;
+        let value;
+        let rows;
+        try {
+            for (; i < objectList.length; i++) {
+                const object = objectList[i];
+                rows = [];
+                j = 0;
+                for (; j < keys.length; j++) {
+                    value = object[keys[j]];
+                    rows[j] = this.toSqlStr(value, asserts[j]?.assertJsType);
+                }
+                str += ",\n(" + rows.join(",") + ")";
+            }
+        }
+        catch (error) {
+            let message = error instanceof Error ? error.message : String(error);
+            throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
+        }
+        return str;
+    }
+    objectToValues(object, keys_types) {
+        let type;
+        let keys;
+        if (keys_types instanceof Array) {
+            keys = keys_types;
+            type = [];
+        }
+        else if (keys_types) {
+            keys = Object.keys(keys_types);
+            type = initColumnAssert(keys, keys_types);
+        }
+        else {
+            keys = Object.keys(object);
+            type = [];
+        }
+        return this._internalObjectToValues(object, keys, type);
+    }
+    _internalObjectToValues(object, keys, type) {
+        const values = [];
+        let i = 0;
+        let key;
+        let value;
+        let assertType;
+        try {
+            for (; i < keys.length; i++) {
+                key = keys[i];
+                value = object[key];
+                assertType = type[i];
+                if (assertType) {
+                    values[i] = this.toSqlStr(value, assertType.assertJsType);
+                    if (assertType.sqlType)
+                        values[i] += "::" + assertType.sqlType;
+                }
+                else
+                    values[i] = this.toSqlStr(value);
+            }
+        }
+        catch (error) {
+            let message = error instanceof Error ? error.message : String(error);
+            throw new Error("字段 '" + key + "' 异常，" + message);
+        }
+        return values.join(",");
+    }
+    /**
+     * 将数组列表转为 SQL 的一个 value
+     * @example 返回示例： " 'abc', '6', 'now()' "
+     */
+    toValues(values) {
+        return values.map((v) => this.toSqlStr(v)).join(",");
+    }
+    createValues(asName, values, valuesTypes) {
+        if (values.length === 0)
+            throw new Error("values 不能为空");
+        const insertKeys = Object.keys(valuesTypes);
+        const defaultValues = [];
+        const asserts = new Array(insertKeys.length);
+        const valuesStr = new Array(values.length);
+        {
+            const column0 = new Array(insertKeys.length);
+            let columnName;
+            let item;
+            let sqlType;
+            let assertJsType;
+            let value;
+            for (let i = 0; i < insertKeys.length; i++) {
+                columnName = insertKeys[i];
+                item = valuesTypes[columnName];
+                if (typeof item === "string") {
+                    sqlType = item;
+                    defaultValues[i] = "NULL";
+                }
+                else {
+                    sqlType = item.sqlType;
+                    assertJsType = item.assertJsType;
+                    asserts[i] = assertJsType;
+                    defaultValues[i] = item.sqlDefault ?? "NULL";
+                }
+                value = values[0][columnName];
+                if (value === undefined)
+                    column0[i] = defaultValues[i] + "::" + sqlType;
+                else
+                    column0[i] = this.toSqlStr(value, assertJsType) + "::" + sqlType;
+            }
+            valuesStr[0] = "(" + column0.join(",") + ")";
+        }
+        let items = new Array(insertKeys.length);
+        let value;
+        for (let i = 1; i < values.length; i++) {
+            for (let j = 0; j < insertKeys.length; j++) {
+                value = values[i][insertKeys[j]];
+                if (value === undefined)
+                    items[j] = defaultValues[j];
+                else
+                    items[j] = this.toSqlStr(value, asserts[j]);
+            }
+            valuesStr[i] = "(" + items.join(",") + ")";
+        }
+        return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
+    }
+}
+class YourValuesAs extends SqlStatementDataset {
+    constructor(columns, asName, valuesStr) {
+        super();
+        this.#asName = asName;
+        this.#valuesStr = valuesStr;
+        this.#sql = `(VALUES\n${this.#valuesStr})\nAS ${this.#asName}(${columns.join(",")})`;
+    }
+    #asName;
+    #valuesStr;
+    #sql;
+    toSelect() {
+        return this.#sql;
+    }
+    toString() {
+        return this.#sql;
+    }
+}
+function initColumnAssert(keys, keys_types) {
+    let key;
+    let value;
+    let type = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        value = keys_types[key];
+        if (typeof value === "string") {
+            type[i] = { sqlType: value };
+        }
+        else {
+            type[i] = value;
+        }
+    }
+    return type;
+}
+class AssertError extends TypeError {
+    constructor(assertType, actual) {
+        super(`Assert ${assertType} type, Actual ${actual} type`);
+    }
+}
+
+export { SqlRaw, SqlValuesCreator };

package/dist/sql_gen/util.js

@@ -0,0 +1,166 @@
+import { condition } from './select/_statement.js';
+
+/**
+ * 获取对象数组中的 key 的集合
+ * @public
+ * @param keepUndefinedKey - 是否保留值为 undefined 的 key
+ */
+function getObjectListKeys(objectList, keepUndefinedKey) {
+    let keys = new Set();
+    for (let i = 0; i < objectList.length; i++) {
+        let obj = objectList[i];
+        let hasKeys = Object.keys(obj);
+        let k;
+        for (let j = 0; j < hasKeys.length; j++) {
+            k = hasKeys[j];
+            if (typeof k !== "string")
+                continue;
+            if (!keepUndefinedKey && obj[k] === undefined)
+                continue;
+            keys.add(k);
+        }
+    }
+    return keys;
+}
+/**
+ * 生成 WHERE 语句
+ * @public
+ * @example
+ * ```ts
+ * where(['a=1','b=2']) // "\nWHERE a=1 AND b=2"
+ * where(['a=1','b=2'],"OR") // "\nWHERE a=1 OR b=2"
+ * where("a=1 OR b=2") // "\nWHERE a=1 OR b=2"
+ * where(()=>"a=1 OR b=2") // "\nWHERE a=1 AND b=2"
+ * where([]) // ""
+ * where(undefined) // ""
+ * ```
+ */
+function where(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nWHERE " + sql;
+    return "";
+}
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+function having(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
+}
+/**
+ * @public
+ * @example
+ * ```ts
+ * selectColumns({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns("c1,count(*) AS c2,column as c3")  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+function selectColumns(columns) {
+    if (typeof columns === "function")
+        columns = columns();
+    switch (typeof columns) {
+        case "string":
+            return columns;
+        case "object": {
+            if (columns instanceof Array) {
+                if (columns.length === 0)
+                    throw new Error("没有选择任何列");
+                return columns.join(",");
+            }
+            else {
+                let sql = "";
+                const keys = Object.keys(columns);
+                if (keys.length === 0)
+                    throw new Error("没有选择任何列");
+                let k = keys[0];
+                let v = columns[k];
+                if (typeof v === "string")
+                    sql += v + " AS " + k;
+                else
+                    sql += k;
+                for (let i = 1; i < keys.length; i++) {
+                    k = keys[i];
+                    v = columns[k];
+                    sql += ",";
+                    if (typeof v === "string")
+                        sql += v + " AS " + k;
+                    else
+                        sql += k;
+                }
+                return sql;
+            }
+        }
+        default:
+            throw new TypeError("columns 应为 string 或 object 类型");
+    }
+}
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * @example
+ * ```ts
+ * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
+ * orderBy("age DESC NULLS FIRST,num ASC");
+ * orderBy(["age DESC NULLS FIRST", "num ASC"]);
+ * orderBy([
+ *    { key: "age", asc: false, nullLast: false },
+ *    { key: "num", asc: true },
+ *  ]);
+ * orderBy({ age: "DESC NULLS FIRST", num: true });
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * ```
+ */
+function orderBy(by) {
+    if (typeof by === "function")
+        by = by();
+    let sql = "";
+    if (!by)
+        return sql;
+    if (typeof by === "string") {
+        sql += "\nORDER BY " + by;
+    }
+    else if (by instanceof Array) {
+        if (by.length) {
+            sql += "\nORDER BY " + handlerOrderValue(by[0]);
+            for (let i = 1; i < by.length; i++)
+                sql += "," + handlerOrderValue(by[i]);
+        }
+    }
+    else {
+        let keys = Object.keys(by);
+        if (keys.length) {
+            let key = keys[0];
+            let value = by[key];
+            sql += "\nORDER BY " + key + " " + (typeof value === "string" ? value : value ? "ASC" : "DESC");
+            for (let i = 1; i < keys.length; i++) {
+                key = keys[i];
+                value = by[key];
+                sql += "," + key + " ";
+                if (typeof value === "string")
+                    sql += value;
+                else
+                    sql += value ? "ASC" : "DESC";
+            }
+        }
+    }
+    return sql;
+}
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
+    else {
+        let str = value.key + " " + (value.asc ? "ASC" : "DESC");
+        if (value.nullLast !== undefined)
+            str += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+        return str;
+    }
+}
+
+export { getObjectListKeys, having, orderBy, selectColumns, where };

package/dist/sql_gen/your_table/checker.js

@@ -0,0 +1,82 @@
+import { CustomDbType } from './infer_db_type.js';
+
+/** @public */
+class TypeChecker {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    check(value) {
+        const map = this.map;
+        let v;
+        for (const [k, expect] of map) {
+            v = value[k];
+            let err;
+            if (v === null) {
+                if (expect.notNull)
+                    throw new Error(`${k} 不能为空`);
+                continue;
+            }
+            else if (v === undefined) {
+                if (expect.sqlDefault === undefined && expect.notNull)
+                    throw new Error(`${k} 不能为 undefined`);
+                continue;
+            }
+            else if (expect.isArray) {
+                if (v instanceof Array)
+                    err = this.checkArray(v, expect.type);
+                else
+                    err = getErrStr(`Array<${expect.type.name}>`, typeof v);
+            }
+            else {
+                err = this.checkItem(v, expect.type);
+            }
+            if (err)
+                throw new Error(`Key ${k} error: ${err}`);
+        }
+        return value;
+    }
+    checkList(value) {
+        let i = 0;
+        try {
+            for (let i = 0; i < value.length; i++) {
+                this.check(value[i]);
+            }
+            return value;
+        }
+        catch (error) {
+            throw new Error(`Item ${i}, ${error.message}`);
+        }
+    }
+    checkArray(v, expect) {
+        let err;
+        for (let i = 0; i < v.length; i++) {
+            err = this.checkItem(v[i], expect);
+            if (err)
+                return `Item[${i}] ${err}`;
+        }
+    }
+    checkItem(v, expect) {
+        if (expect instanceof CustomDbType) {
+            if (expect.is(v))
+                return;
+        }
+        else {
+            if (v instanceof expect)
+                return;
+        }
+        let actName = typeof v;
+        if (actName === "object") {
+            if (v === null)
+                actName = "null";
+            else
+                actName = v.constructor?.name ?? "object";
+        }
+        return getErrStr(expect.name, typeof v);
+    }
+}
+function getErrStr(expect, actual) {
+    return `Expect ${expect}, Actual ${actual}`;
+}
+
+export { TypeChecker };

package/dist/sql_gen/your_table/infer_db_type.js

@@ -0,0 +1,76 @@
+/**
+ * 表格列的信息
+ * @public
+ */
+class ColumnMeta {
+    type;
+    sqlType;
+    notNull;
+    isArray;
+    sqlDefault;
+    constructor(type, 
+    /** 数据库原始数据类型 */
+    sqlType, 
+    /** 是否非空 */
+    notNull = false, 
+    /** 是否是数组类型 */
+    isArray = false, 
+    /** 数据库原始默认值 */
+    sqlDefault) {
+        this.type = type;
+        this.sqlType = sqlType;
+        this.notNull = notNull;
+        this.isArray = isArray;
+        this.sqlDefault = sqlDefault;
+    }
+    /** 校验 value 的类型 */
+    checkValue(value) {
+        if (typeof this.type === "function")
+            return value instanceof this.type;
+        return this.type.is(value);
+    }
+}
+/**
+ * 数据库类型到JS类型的映射
+ * @public
+ */
+class YourTypeMap {
+    typeMap;
+    static create(rawTypeMap) {
+        return new this(rawTypeMap);
+    }
+    constructor(typeMap = {}) {
+        this.typeMap = typeMap;
+    }
+    genColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type, notNull, false, defaultValue);
+        return column;
+    }
+    genArrColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type + "[]", notNull, true, defaultValue);
+        return column;
+    }
+}
+function baseType(v) {
+    return typeof v === this.name;
+}
+/**
+ * 自定义数据类型
+ * @public
+ */
+class CustomDbType {
+    is;
+    name;
+    static bigint = new CustomDbType(baseType, "bigint");
+    static number = new CustomDbType(baseType, "number");
+    static string = new CustomDbType(baseType, "string");
+    static boolean = new CustomDbType(baseType, "boolean");
+    constructor(is, name) {
+        this.is = is;
+        this.name = name;
+    }
+}
+
+export { ColumnMeta, CustomDbType, YourTypeMap };

package/dist/sql_gen/your_table/table.js

@@ -0,0 +1,33 @@
+import { DbTableQuery } from '../select/TableQuery.js';
+import { TypeChecker } from './checker.js';
+
+/**
+ * 完整数据库表数据
+ * @public
+ */
+class YourTable extends DbTableQuery {
+    define;
+    constructor(name, define, sqlValue) {
+        super(name, sqlValue);
+        this.define = define;
+        this.columns = Object.keys(define);
+    }
+    columns;
+    getColumnMeta(name) {
+        return Reflect.get(this.define, name);
+    }
+    createTypeChecker(keys) {
+        let map = new Map();
+        let defined = this.define;
+        let k;
+        for (let i = 0; i < keys.length; i++) {
+            k = keys[i];
+            if (defined[k] === undefined)
+                throw new Error(`key ${k} 未定义`);
+            map.set(k, defined[k]);
+        }
+        return new TypeChecker(map);
+    }
+}
+
+export { YourTable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
@@ -29,8 +29,8 @@
     "url": "https://github.com/asnowc/yoursql"
   },
   "exports": {
-    ".": "./dist/sql_gen.js",
-    "./client": "./dist/client.js"
+    ".": "./dist/sql_gen/mod.js",
+    "./client": "./dist/client/mod.js"
   },
   "files": [
     "dist/**/*.js",