@asla/yoursql 0.8.2 → 0.8.4

package/dist/sql_gen/select/query_chain_insert.d.ts

@@ -1,20 +1,22 @@
 import { ConditionParam, Constructable, SelectParam } from "../util.ts";
-import { SqlStatementDataset, SqlStatement, ChainModifyWhere, ChainOnConflict, ChainConflictDo, ChainModifyReturning } from "./query_chain_abstract.ts";
+import { SqlStatementDataset, SqlStatement } from "./chain_base.ts";
+import { ChainAfterConflictDo, ChainModifyReturning, ChainInsert, ChainDelete, ChainUpdate } from "./chain_modify.ts";
 import { TableType } from "./type.ts";
-export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainOnConflict<T>, ChainModifyWhere<T> {
+export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainInsert<T>, ChainUpdate<T>, ChainDelete<T> {
     readonly sql: string;
     constructor(sql: string);
     returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
-    onConflict(onConflict: Constructable<readonly string[] | string>): ChainConflictDo<T>;
+    onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
     toString(): string;
 }
-export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainConflictDo<T> {
+export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainAfterConflictDo<T> {
     readonly sql: string;
     constructor(sql: string);
     doUpdate(set?: Constructable<string | {
         [key: string]: string | undefined;
-    }>): ChainModifyWhere<T>;
+    }>): ChainModifyReturning<T>;
     doNotThing(): ChainModifyReturning<T>;
+    toString(): string;
 }
 //# sourceMappingURL=query_chain_insert.d.ts.map

package/dist/sql_gen/select/query_chain_insert.js

@@ -0,0 +1,67 @@
+import { selectColumns, where } from '../util.js';
+import { createUpdateSetFromObject } from './_statement.js';
+import { SqlStatement, SqlTextStatementDataset } from './chain_base.js';
+
+class SqlChainModify extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            columnsStr = selectColumns(returns);
+        }
+        let sql = this.toString() + "\nRETURNING " + columnsStr;
+        return new SqlTextStatementDataset(sql);
+    }
+    onConflict(onConflict) {
+        if (typeof onConflict === "function")
+            onConflict = onConflict();
+        if (typeof onConflict !== "string")
+            onConflict = onConflict.join(",");
+        let sql = this.toString() + `\nON CONFLICT (${onConflict})`;
+        return new SqlInsertConflictBranch(sql);
+    }
+    where(where$1) {
+        const sql = where(where$1);
+        return new SqlChainModify(this.toString() + sql);
+    }
+    toString() {
+        return this.sql;
+    }
+}
+class SqlInsertConflictBranch {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    doUpdate(set) {
+        if (typeof set === "function")
+            set = set();
+        let sql = this.sql;
+        if (typeof set === "object") {
+            sql += "\nDO UPDATE ";
+            sql += createUpdateSetFromObject(set);
+        }
+        else if (set)
+            sql += "DO UPDATE\n" + set;
+        else
+            sql += "DO NOTHING";
+        return new SqlChainModify(sql);
+    }
+    doNotThing() {
+        return new SqlChainModify(this.sql + " DO NOTHING");
+    }
+    toString() {
+        return this.sql;
+    }
+}
+
+export { SqlChainModify, SqlInsertConflictBranch };

package/dist/sql_gen/select/query_chain_select.d.ts

@@ -1,15 +1,16 @@
-import { ChainSelectGroupBy, ChainSelectHaving, ChainSelectLimit, ChainSelectWhere, SqlSelectable, SqlStatementDataset, SqlTextStatementDataset } from "./query_chain_abstract.ts";
+import { SqlSelectable, SqlTextStatementDataset } from "./chain_base.ts";
+import { ChainSelect, ChainSelectAfterHaving, ChainSelectAfterLimit, ChainSelectAfterOrderBy, ChainSelectAfterGroupBy, ChainSelectAfterWhere } from "./chain_select.ts";
 import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
 /**
  * @public ChainSelectWhere 的默认实现
  */
-export declare class SqlSelectChain<T extends TableType> extends SqlTextStatementDataset<T> implements ChainSelectWhere<T> {
-    where(param?: Constructable<ConditionParam | void>): ChainSelectGroupBy<T>;
-    groupBy(columns: string | string[]): ChainSelectHaving<T>;
-    having(param?: Constructable<ConditionParam | void>): ChainSelectLimit<T>;
-    orderBy(param?: Constructable<OrderByParam | void>): ChainSelectLimit<T>;
-    limit(limit?: number, offset?: number): SqlStatementDataset<T>;
+export declare class SqlSelectChain<T extends TableType> extends SqlTextStatementDataset<T> implements ChainSelect<T> {
+    where(param?: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
+    groupBy(columns: string | string[]): ChainSelectAfterGroupBy<T>;
+    having(param?: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
+    orderBy(param?: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+    limit(limit?: number, offset?: number): ChainSelectAfterLimit<T>;
 }
 /** @public */
 export declare class Selection {
@@ -25,7 +26,7 @@ export declare class Selection {
     crossJoin(selectable: Constructable<SqlSelectable | string>, as?: string | undefined): Selection;
     from(selectable: Constructable<SqlSelectable | string>, as?: string): Selection;
     /** 选择全部列 */
-    select<T extends TableType = Record<string, any>>(columns: "*"): ChainSelectWhere<T>;
+    select<T extends TableType = Record<string, any>>(columns: "*"): ChainSelect<T>;
     /**
      * 自定义SQL选择语句
      * @example
@@ -33,7 +34,7 @@ export declare class Selection {
      * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
      * ```
      */
-    select(columns: Constructable<SelectParam>): ChainSelectWhere<Record<string, any>>;
+    select(columns: Constructable<SelectParam>): ChainSelect<Record<string, any>>;
     /**
      * 通过 object 选择 列
      * @example
@@ -43,6 +44,6 @@ export declare class Selection {
      */
     select<T extends TableType>(columns: Constructable<{
         [key in keyof T]: string | boolean;
-    } | string>): ChainSelectWhere<T>;
+    } | string>): ChainSelect<T>;
 }
 //# sourceMappingURL=query_chain_select.d.ts.map

package/dist/sql_gen/select/query_chain_select.js

@@ -0,0 +1,105 @@
+import { SqlTextStatementDataset } from './chain_base.js';
+import { where, having, orderBy, selectColumns } from '../util.js';
+import { condition } from './_statement.js';
+
+var _a;
+/**
+ * @public ChainSelectWhere 的默认实现
+ */
+class SqlSelectChain extends SqlTextStatementDataset {
+    where(param) {
+        return new SqlSelectChain(this.toString() + where(param));
+    }
+    groupBy(columns) {
+        let sql = this.toString();
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new SqlSelectChain(sql);
+    }
+    having(param) {
+        return new SqlSelectChain(this.toString() + having(param));
+    }
+    orderBy(param) {
+        return new SqlSelectChain(this.toString() + orderBy(param));
+    }
+    limit(limit, offset) {
+        let sql = this.toString();
+        let type;
+        if (limit) {
+            type = typeof limit;
+            if (type === "number" || type === "bigint")
+                sql += "\nLIMIT " + limit;
+            else
+                throw new TypeError("limit 必须是个整数：" + limit);
+        }
+        if (offset) {
+            type = typeof offset;
+            if (type === "number" || type === "bigint")
+                sql += "\nOFFSET " + offset;
+            else
+                throw new TypeError("offset 必须是个整数：" + limit);
+        }
+        return new SqlTextStatementDataset(sql);
+    }
+}
+function fromAs(selectable, as) {
+    if (typeof selectable === "function")
+        selectable = selectable();
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (as)
+        sql += " AS " + as;
+    return sql;
+}
+/** @public */
+class Selection {
+    static from(selectable, as) {
+        return new this(selectable, as);
+    }
+    #sql;
+    constructor(selectable, as) {
+        this.#sql = fromAs(selectable, as);
+    }
+    toString() {
+        return "FROM " + this.#sql;
+    }
+    #join(type, selectable, as, on) {
+        let sql = this.#sql + "\n" + type + " " + fromAs(selectable, as);
+        if (on) {
+            sql += " ON " + condition(on);
+        }
+        return new _a(sql);
+    }
+    fullJoin(selectable, as, on) {
+        return this.#join("FULL JOIN", selectable, as, on);
+    }
+    innerJoin(selectable, as, on) {
+        return this.#join("INNER JOIN", selectable, as, on);
+    }
+    leftJoin(selectable, as, on) {
+        return this.#join("LEFT JOIN", selectable, as, on);
+    }
+    rightJoin(selectable, as, on) {
+        return this.#join("RIGHT JOIN", selectable, as, on);
+    }
+    naturalJoin(selectable, as) {
+        return this.#join("NATURAL JOIN", selectable, as);
+    }
+    crossJoin(selectable, as) {
+        return this.#join("CROSS JOIN", selectable, as);
+    }
+    from(selectable, as) {
+        return new _a(this.#sql + "," + fromAs(selectable, as));
+    }
+    select(columnsIn) {
+        if (typeof columnsIn === "function")
+            columnsIn = columnsIn();
+        let sql = "SELECT " + selectColumns(columnsIn);
+        sql += "\n" + this.toString();
+        return new SqlSelectChain(sql);
+    }
+}
+_a = Selection;
+
+export { Selection, SqlSelectChain };

package/dist/sql_gen/sql_value/db_type.js

@@ -0,0 +1,40 @@
+import { SqlValuesCreator } from './sql_value.js';
+
+/** @public PgSql 转换器 */
+const pgSqlTransformer = new Map([
+    [
+        Array,
+        function encodePgArray(value) {
+            if (value.length === 0)
+                return "NULL";
+            const valueStr = [];
+            let type;
+            let basicType;
+            for (let i = 0; i < value.length; i++) {
+                if (value[i] === null || value[i] === undefined)
+                    valueStr[i] = this.toSqlStr(value[i]);
+                else if (type) {
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+                else {
+                    basicType = typeof value[i];
+                    if (basicType === "object") {
+                        type = this.getClassType(value[i]);
+                    }
+                    else
+                        type = basicType;
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+            }
+            return "ARRAY[" + valueStr.join(",") + "]";
+        },
+    ],
+    [
+        Date,
+        function (value) {
+            return SqlValuesCreator.string(value.toISOString());
+        },
+    ],
+]);
+
+export { pgSqlTransformer };

package/dist/sql_gen/sql_value/sql_value.d.ts

@@ -1,4 +1,4 @@
-import { SqlStatementDataset } from "../select/query_chain_abstract.ts";
+import { SqlStatementDataset } from "../select/chain_base.ts";
 declare const SQL_RAW: unique symbol;
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型

package/dist/sql_gen/sql_value/sql_value.js

@@ -0,0 +1,304 @@
+import { getObjectListKeys } from '../util.js';
+import { SqlStatementDataset } from '../select/chain_base.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 };