@asla/yoursql 0.5.0 → 0.5.1

package/dist/mod.js

@@ -62,35 +62,41 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
  *
  * ```
  */
-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 having(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
 }
-function genCondition(condition, statement, type = "AND") {
-    if (typeof condition === "function")
-        condition = condition();
-    type = " " + type + " ";
-    let sql = "";
-    if (typeof condition === "string")
-        sql += "\n" + statement + " " + condition;
+function condition(conditions, type = "AND") {
+    if (typeof conditions === "function")
+        conditions = conditions();
+    if (!conditions)
+        return;
+    if (typeof conditions === "string")
+        return conditions;
     else {
-        if (condition.length)
-            sql += "\n" + statement + " " + condition[0];
-        for (let i = 1; i < condition.length; i++)
-            sql += type + condition[i];
+        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;
     }
-    return sql;
 }
 /**
  * @public
@@ -152,9 +158,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) {
@@ -668,6 +674,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,28 @@
 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, 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;
+    }, 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 +36,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/select.d.ts

@@ -1,5 +1,5 @@
 import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
-import { OrderByParam, WhereParam } from "../util.ts";
+import { OrderByParam, ConditionParam } 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 {
@@ -35,9 +35,9 @@ export declare class 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>(columns: {
         [key in keyof T]: string | boolean;
     }): CurrentWhere<T>;
-    select<T extends TableType = TableType>(columns: "*" | string[] | TableType): CurrentWhere<T>;
+    select(columns: "*" | string[] | Record<string, string | boolean>): CurrentWhere<TableType>;
 }
 //# sourceMappingURL=select.d.ts.map

package/dist/util.d.ts

@@ -6,7 +6,7 @@ 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
@@ -14,13 +14,13 @@ export type WhereParam = string | string[];
  *
  * ```
  */
-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
  * ```ts
@@ -54,5 +54,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.1",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",