@asla/yoursql 0.5.0 → 0.5.2

package/dist/mod.js

@@ -33,6 +33,53 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function selectColumnsOrTable(columns) {
+    let sqlSelect;
+    let select;
+    if (columns instanceof Array) {
+        sqlSelect = columns;
+        select = columns;
+    }
+    else {
+        sqlSelect = [];
+        select = [];
+        let c;
+        for (const key of Object.keys(columns)) {
+            c = columns[key];
+            if (typeof c === "string" && c !== key) {
+                sqlSelect.push(key + " AS " + c);
+                select.push(c);
+            }
+            else if (c) {
+                sqlSelect.push(key);
+                select.push(key);
+            }
+        }
+    }
+    if (select.length === 0)
+        throw new Error("选择列为空");
+    return { columns: select, sqlColumns: sqlSelect.join(", ") };
+}
+function condition(conditions, type = "AND") {
+    if (typeof conditions === "function")
+        conditions = conditions();
+    if (!conditions)
+        return;
+    if (typeof conditions === "string")
+        return conditions;
+    else {
+        if (conditions.length) {
+            let sql = "";
+            type = " " + type + " ";
+            sql += conditions[0];
+            for (let i = 1; i < conditions.length; i++)
+                sql += type + conditions[i];
+            return sql;
+        }
+        return;
+    }
+}
+
 /**
  * 获取对象数组中的 key 的集合
  * @public
@@ -58,82 +105,72 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
 /**
  * 生成 WHERE 语句
  * @public
+ * @example
  * ```ts
  *
  * ```
  */
-function where(condition, type = "AND") {
-    if (!condition)
-        return "";
-    return genCondition(condition, "WHERE", type);
+function where(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nWHERE " + sql;
+    return "";
 }
 /**
  *
  * 生成 HAVING 语句
  * @public
  */
-function having(condition, type = "AND") {
-    if (!condition)
-        return "";
-    return genCondition(condition, "HAVING", type);
-}
-function genCondition(condition, statement, type = "AND") {
-    if (typeof condition === "function")
-        condition = condition();
-    type = " " + type + " ";
-    let sql = "";
-    if (typeof condition === "string")
-        sql += "\n" + statement + " " + condition;
-    else {
-        if (condition.length)
-            sql += "\n" + statement + " " + condition[0];
-        for (let i = 1; i < condition.length; i++)
-            sql += type + condition[i];
-    }
-    return sql;
+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"
+ * selectColumns("c1,count(*) AS c2,column as c3")  //  "c1,count(*) AS c2,column as c3"
  * ```
  */
 function selectColumns(columns) {
-    let sql = "";
-    if (columns instanceof Array) {
-        if (columns.length)
-            sql += columns[0];
-        else
-            throw new Error("没有选择任何列");
-        for (let i = 1; i < columns.length; i++)
-            sql += "," + columns[i];
-    }
-    else {
-        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 columns === "function")
+        columns = columns();
+    switch (typeof columns) {
+        case "string":
+            return columns;
+        case "object": {
+            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 类型");
     }
-    return sql;
 }
 /**
  * 生成 ORDER BY 语句, d
  * @public
+ * @example
  * ```ts
  * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
  * orderBy("age DESC NULLS FIRST,num ASC");
@@ -152,9 +189,9 @@ function orderBy(by) {
     if (typeof by === "function")
         by = by();
     let sql = "";
+    if (!by)
+        return sql;
     if (typeof by === "string") {
-        if (!by)
-            return sql;
         sql += "\nORDER BY " + by;
     }
     else if (by instanceof Array) {
@@ -168,14 +205,16 @@ function orderBy(by) {
         let keys = Object.keys(by);
         if (keys.length) {
             let key = keys[0];
-            sql += "\nORDER BY " + key + " " + by[key];
+            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 by[key] === "string")
-                    sql += by[key];
+                if (typeof value === "string")
+                    sql += value;
                 else
-                    sql += by[key] ? "ASC" : "DESC";
+                    sql += value ? "ASC" : "DESC";
             }
         }
     }
@@ -610,55 +649,24 @@ class Selection {
         return new _a(__classPrivateFieldGet(this, _Selection_sql, "f") + "," + fromAs(selectable, as));
     }
     select(columnsIn) {
-        let sql = "SELECT ";
         let columns = [];
-        if (typeof columnsIn === "string")
-            sql += columnsIn;
-        else {
-            sql += selectColumns(columnsIn);
-            if (columnsIn instanceof Array) ;
-            else
-                columns = Object.keys(columnsIn);
-        }
+        if (typeof columnsIn === "function")
+            columnsIn = columnsIn();
+        if (typeof columnsIn === "object")
+            columns = Object.keys(columnsIn);
+        let sql = "SELECT " + selectColumns(columnsIn);
         sql += "\n" + this.toString();
         return new AfterSelectImpl(sql, columns);
     }
 }
 _a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakSet(), _Selection_join = function _Selection_join(type, selectable, as, on) {
     let sql = __classPrivateFieldGet(this, _Selection_sql, "f") + "\n" + type + " " + fromAs(selectable, as);
-    if (on)
-        sql += " ON " + on;
+    if (on) {
+        sql += " ON " + condition(on);
+    }
     return new _a(sql);
 };
 
-function selectColumnsOrTable(columns) {
-    let sqlSelect;
-    let select;
-    if (columns instanceof Array) {
-        sqlSelect = columns;
-        select = columns;
-    }
-    else {
-        sqlSelect = [];
-        select = [];
-        let c;
-        for (const key of Object.keys(columns)) {
-            c = columns[key];
-            if (typeof c === "string" && c !== key) {
-                sqlSelect.push(key + " AS " + c);
-                select.push(c);
-            }
-            else if (c) {
-                sqlSelect.push(key);
-                select.push(key);
-            }
-        }
-    }
-    if (select.length === 0)
-        throw new Error("选择列为空");
-    return { columns: select, sqlColumns: sqlSelect.join(", ") };
-}
-
 /** @public */
 class DbTableQuery extends DbTable {
     constructor(name, columns, statement) {
@@ -668,6 +676,9 @@ class DbTableQuery extends DbTable {
     fromAs(as) {
         return new Selection(this, as);
     }
+    select(columns, as) {
+        return this.fromAs(as).select(columns);
+    }
     insert(values, option) {
         let insertCol;
         let valuesStr;

package/dist/select/TableQuery.d.ts

@@ -1,13 +1,30 @@
 import { SqlValuesCreator, SqlRaw } from "../sql_value/sql_value.ts";
 import { ColumnsSelected, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
-import { Selection } from "./select.ts";
+import { CurrentWhere, Selection } from "./select.ts";
 import { DbTable, SqlQueryStatement } from "./selectable.ts";
-import { WhereParam } from "../util.ts";
+import { ConditionParam } from "../util.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
     private statement;
     constructor(name: string, columns: readonly string[], statement: SqlValuesCreator);
     fromAs(as?: string): Selection;
+    /** 选择单表全部列 */
+    select(columns: "*", as?: string): CurrentWhere<T>;
+    /**
+     * 选择单表
+     * @param columns - 对象选择
+     */
+    select<R extends {
+        [key in keyof T]?: string | boolean;
+    } | Record<string, string>>(columns: R | (() => R), as?: string): CurrentWhere<{
+        [key in keyof R]: R[key] extends boolean ? key extends keyof T ? T[key] : unknown : R[key] extends keyof T ? T[R[key]] : unknown;
+    }>;
+    /** 选择单表- 所有类型 */
+    select<R extends {}>(columns: string | {
+        [key in keyof R]?: key extends keyof T ? string | boolean : string;
+    } | (() => string | {
+        [key in keyof R]?: key extends keyof T ? string | boolean : string;
+    }), as?: string): CurrentWhere<R>;
     insert(values: C[] | SqlQueryStatement<C>, option?: InsertOption<T>): string;
     insertWithResult<R extends ColumnsSelected<T>>(values: C[] | SqlQueryStatement<C>, returns: R, option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
     update(values: UpdateRowValue<T>, option?: UpdateOption): string;
@@ -21,14 +38,14 @@ export interface InsertOption<T extends object> {
     updateValues?: {
         [key in keyof T]?: undefined | SqlRaw | T[key];
     };
-    where?: WhereParam;
+    where?: ConditionParam;
 }
 /** @public */
 export interface UpdateOption {
-    where?: WhereParam;
+    where?: ConditionParam;
 }
 /** @public */
 export interface DeleteOption {
-    where?: WhereParam;
+    where?: ConditionParam;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -3,4 +3,10 @@ export declare function selectColumnsOrTable(columns: ColumnsSelectAs<any> | str
     columns: string[];
     sqlColumns: string;
 };
+type ConditionParam = string | string[];
+/**
+ * 生成条件语句
+ */
+export declare function condition(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+export {};
 //# sourceMappingURL=_statement.d.ts.map

package/dist/select/select.d.ts

@@ -1,5 +1,5 @@
 import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
-import { OrderByParam, WhereParam } from "../util.ts";
+import { OrderByParam, ConditionParam, SelectParam } from "../util.ts";
 import type { TableType } from "./type.ts";
 /** @public */
 export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
@@ -7,11 +7,11 @@ export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T>
 }
 /** @public */
 export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
-    orderBy(param: OrderByParam): CurrentLimit<T>;
+    orderBy(param: OrderByParam | (() => OrderByParam | void)): CurrentLimit<T>;
 }
 /** @public */
 export interface CurrentHaving<T extends TableType> extends CurrentOrderBy<T> {
-    having(param: WhereParam | (() => WhereParam)): CurrentLimit<T>;
+    having(param: ConditionParam | (() => ConditionParam | void)): CurrentLimit<T>;
 }
 /** @public */
 export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
@@ -19,7 +19,7 @@ export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
 }
 /** @public */
 export interface CurrentWhere<T extends TableType> extends CurrentGroupBy<T> {
-    where(param: WhereParam | (() => WhereParam)): CurrentGroupBy<T>;
+    where(param: ConditionParam | (() => ConditionParam | void)): CurrentGroupBy<T>;
 }
 /** @public */
 export declare class Selection {
@@ -27,17 +27,35 @@ export declare class Selection {
     static from(selectable: SqlSelectable<any> | string, as?: string): Selection;
     constructor(selectable: SqlSelectable<any> | string, as?: string);
     toString(): string;
-    fullJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
-    innerJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
-    leftJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
-    rightJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    fullJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
+    innerJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
+    leftJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
+    rightJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
     naturalJoin(selectable: SqlSelectable<any>, as?: string | undefined): Selection;
     crossJoin(selectable: SqlSelectable<any>, as?: string | undefined): Selection;
     from(selectable: SqlSelectable<any> | string, as?: string): Selection;
-    select<T extends TableType = TableType>(columns: "*" | string[]): CurrentWhere<T>;
-    select<T extends TableType = TableType>(columns: {
+    /** 选择全部列 */
+    select<T extends TableType = TableType>(columns: "*"): CurrentWhere<T>;
+    /**
+     * 自定义SQL选择语句
+     * @example
+     * ```ts
+     * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
+     * ```
+     */
+    select<T extends TableType = TableType>(columns: string): CurrentWhere<T>;
+    /**
+     * 通过 object 选择 列
+     * @example
+     * ```ts
+     * selection.select({"age":true, c:"count(*)"}) // SELECT age,count(*) AS c FROM ...
+     * ```
+     */
+    select<T extends TableType>(columns: {
         [key in keyof T]: string | boolean;
-    }): CurrentWhere<T>;
-    select<T extends TableType = TableType>(columns: "*" | string[] | TableType): CurrentWhere<T>;
+    } | (() => {
+        [key in keyof T]: string | boolean;
+    })): CurrentWhere<T>;
+    select(columns: SelectParam | (() => SelectParam)): CurrentWhere<TableType>;
 }
 //# sourceMappingURL=select.d.ts.map

package/dist/util.d.ts

@@ -6,29 +6,33 @@ import { OrderValue } from "./select/type.ts";
  */
 export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
 /** @public */
-export type WhereParam = string | string[];
+export type ConditionParam = string | string[];
 /**
  * 生成 WHERE 语句
  * @public
+ * @example
  * ```ts
  *
  * ```
  */
-export declare function where(condition?: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+export declare function where(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
 /**
  *
  * 生成 HAVING 语句
  * @public
  */
-export declare function having(condition?: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+export declare function having(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+/** @public */
+export type SelectParam = string | Record<string, string | boolean>;
 /**
  * @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"
+ * selectColumns("c1,count(*) AS c2,column as c3")  //  "c1,count(*) AS c2,column as c3"
  * ```
  */
-export declare function selectColumns(columns: string[] | Record<string, string | boolean>): string;
+export declare function selectColumns(columns: SelectParam | (() => SelectParam)): string;
 /** @public */
 export type OrderBehavior = {
     key: string;
@@ -40,6 +44,7 @@ export type OrderByParam = string | (string | OrderBehavior)[] | Record<string,
 /**
  * 生成 ORDER BY 语句, d
  * @public
+ * @example
  * ```ts
  * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
  * orderBy("age DESC NULLS FIRST,num ASC");
@@ -54,5 +59,5 @@ export type OrderByParam = string | (string | OrderBehavior)[] | Record<string,
  * orderBy({}) // ""
  * ```
  */
-export declare function orderBy(by: OrderByParam | (() => OrderByParam)): string;
+export declare function orderBy(by?: OrderByParam | void | (() => OrderByParam | void)): string;
 //# sourceMappingURL=util.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",