@asla/yoursql 0.8.0 → 0.8.1

package/dist/mod.js

@@ -33,33 +33,6 @@ 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();
@@ -186,26 +159,33 @@ function selectColumns(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 (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;
             }
-            return sql;
         }
         default:
             throw new TypeError("columns 应为 string 或 object 类型");
@@ -751,8 +731,7 @@ class SqlChainModify extends SqlStatement {
             columnsStr = "*";
         }
         else {
-            const res = selectColumnsOrTable(returns);
-            columnsStr = res.sqlColumns;
+            columnsStr = selectColumns(returns);
         }
         let sql = this.toString() + "\nRETURNING " + columnsStr;
         return new SqlTextStatementDataset(sql);

package/dist/select/_statement.d.ts

@@ -1,8 +1,4 @@
 import { Constructable } from "../util.ts";
-export declare function selectColumnsOrTable(columns: Record<string, boolean | string> | string[]): {
-    columns: string[];
-    sqlColumns: string;
-};
 type ConditionParam = string | string[];
 /**
  * 生成条件语句

package/dist/select/query_chain_abstract.d.ts

@@ -1,5 +1,5 @@
-import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
-import { ColumnsSelected, TableType } from "./type.ts";
+import { ConditionParam, Constructable, OrderByParam, SelectParam } from "../util.ts";
+import { TableType } from "./type.ts";
 /** @public */
 export declare abstract class SqlStatement {
     /** 获取 SQL 语句 */
@@ -55,8 +55,8 @@ export interface ChainSelectWhere<T extends TableType> extends ChainSelectGroupB
 /** @public */
 export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
     returning(columns: "*"): SqlStatementDataset<T>;
-    returning(columns: Constructable<ColumnsSelected<T> | string>): SqlStatementDataset<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<ColumnsSelected<R> | string>): SqlStatementDataset<R>;
+    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
+    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
 }
 /** @public */
 export interface ChainModifyWhere<T extends TableType = {}> extends ChainModifyReturning<T> {

package/dist/select/query_chain_insert.d.ts

@@ -1,10 +1,10 @@
-import { ConditionParam, Constructable } from "../util.ts";
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
 import { SqlStatementDataset, SqlStatement, ChainModifyWhere, ChainOnConflict, ChainConflictDo, ChainModifyReturning } from "./query_chain_abstract.ts";
-import { ColumnsSelected, TableType } from "./type.ts";
+import { TableType } from "./type.ts";
 export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainOnConflict<T>, ChainModifyWhere<T> {
     readonly sql: string;
     constructor(sql: string);
-    returning<R extends {}>(returns: Constructable<ColumnsSelected<any> | "*">): SqlStatementDataset<R>;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
     onConflict(onConflict: Constructable<readonly string[] | string>): ChainConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
     toString(): string;

package/dist/select/type.d.ts

@@ -20,26 +20,8 @@ export type UpdateRowValue<T extends object> = {
 };
 /** @public */
 export type OrderValue = "ASC" | "DESC";
-/**
- * 表的选择参数
- * @public
- */
-export type ColumnsSelected<T extends TableType> = {
-    [key in keyof T]?: boolean | string;
-};
-/**
- * 从一个表格选择列，生成新的表格类型
- * @public
- */
-export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends {
-    [key in keyof T]?: boolean | string;
-} ? {
-    [key in keyof T as R[key] extends true ? key : StringOnly<R[key]>]: T[key];
-} : never;
-type StringOnly<T> = T extends string ? T : never;
 /** @public */
 export type TableType = {
     [key: string]: any;
 };
-export {};
 //# sourceMappingURL=type.d.ts.map

package/dist/util.d.ts

@@ -30,7 +30,7 @@ export declare function where(conditions?: Constructable<ConditionParam | void>,
  */
 export declare function having(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
 /** @public */
-export type SelectParam = string | Record<string, string | boolean>;
+export type SelectParam = string | string[] | Record<string, string | boolean>;
 /**
  * @public
  * @example

package/package.json

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