@asla/yoursql 0.10.1 → 0.11.0

package/dist/sql_gen/statement/insert.js

@@ -1,107 +1,13 @@
-import { selectColumns } from '../util.js';
-import { whereToString, createUpdateSetFromObject } from '../_statement.js';
-import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { InsertChain } from './insert_impl.js';
 
-function insertInto(table, columns) {
+/** @public */
+const insertInto = function insertInto(table, columns) {
     if (columns) {
         return new InsertChain(`INSERT INTO ${table}(${columns.join(",")})`);
     }
     else {
         return new InsertChain(`INSERT INTO ${table}`);
     }
-}
-class InsertChain extends SqlStatement {
-    sql;
-    constructor(sql) {
-        super();
-        this.sql = sql;
-    }
-    values(statement) {
-        if (typeof statement === "function")
-            statement = statement();
-        switch (typeof statement) {
-            case "object":
-                if (statement instanceof Array) {
-                    statement = statement.join(",\n");
-                }
-                else {
-                    throw new TypeError("参数 statement 类型错误");
-                }
-                break;
-            case "string":
-                break;
-            default:
-                throw new TypeError("参数 statement 类型错误");
-        }
-        return new InsertChain(this.sql + `\nVALUES\n${statement}`);
-    }
-    select(statement) {
-        if (typeof statement === "function")
-            statement = statement();
-        return new InsertChain(this.sql + `\n${statement}`);
-    }
-    returning(returns) {
-        if (typeof returns === "function")
-            returns = returns();
-        let columnsStr;
-        if (returns === "*") {
-            columnsStr = "*";
-        }
-        else {
-            columnsStr = selectColumns(returns);
-        }
-        let sql = this.genSql() + "\nRETURNING " + columnsStr;
-        return new SqlTextStatementDataset(sql);
-    }
-    onConflict(onConflict) {
-        if (typeof onConflict === "function")
-            onConflict = onConflict();
-        if (typeof onConflict !== "string")
-            onConflict = onConflict.join(",");
-        let sql = this.genSql() + `\nON CONFLICT (${onConflict})`;
-        return new InsertAfterOnConflict(sql);
-    }
-    where(where) {
-        const sql = whereToString(where);
-        return new InsertChain(this.genSql() + sql);
-    }
-    genSql() {
-        return this.sql;
-    }
-}
-class InsertAfterOnConflict {
-    sql;
-    constructor(sql) {
-        this.sql = sql;
-    }
-    doUpdate(set) {
-        if (typeof set === "function")
-            set = set();
-        let sql;
-        switch (typeof set) {
-            case "object": {
-                if (set instanceof Array) {
-                    sql = "\nDO UPDATE SET " + set.join(", ");
-                }
-                else {
-                    sql = "\nDO UPDATE " + createUpdateSetFromObject(set);
-                }
-                break;
-            }
-            case "string":
-                sql = "\nDO UPDATE " + set;
-                break;
-            default:
-                throw new TypeError("参数 set 类型错误");
-        }
-        return new InsertChain(this.sql + sql);
-    }
-    doNotThing() {
-        return new InsertChain(this.sql + " DO NOTHING");
-    }
-    toString() {
-        return this.sql;
-    }
-}
+};
 
 export { insertInto };

package/dist/sql_gen/statement/insert_chain.d.ts

@@ -1,6 +1,11 @@
 import { Constructable } from "../util.ts";
 import { ChainModifyReturning } from "./_modify.ts";
 /** @public */
+export interface InsertIntoSqlGenerator {
+    (target: string): ChainInsert;
+    (table: string, columns: readonly string[]): ChainInsert;
+}
+/** @public */
 export interface ChainAfterConflict {
     doNotThing(): ChainInsertReturning;
     doUpdate(set: Constructable<string | readonly string[] | Record<string, string>>): ChainInsertReturning;

package/dist/sql_gen/statement/insert_impl.d.ts

@@ -0,0 +1,14 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { SqlStatementDataset, SqlStatement } from "../SqlStatement.ts";
+import { ChainAfterConflict, ChainInsert, ChainInsertAfterValues, ChainInsertReturning } from "./insert_chain.ts";
+export declare class InsertChain extends SqlStatement implements ChainInsert {
+    private sql;
+    constructor(sql: string);
+    values(statement: Constructable<string | readonly string[]>): ChainInsertAfterValues;
+    select(statement: Constructable<string>): ChainInsertAfterValues;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
+    onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflict;
+    where(where: Constructable<ConditionParam | void>): ChainInsertReturning;
+    genSql(): string;
+}
+//# sourceMappingURL=insert_impl.d.ts.map

package/dist/sql_gen/statement/insert_impl.js

@@ -0,0 +1,99 @@
+import { selectColumns } from '../util.js';
+import { whereToString, createUpdateSetFromObject } from '../_statement.js';
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+
+class InsertChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    values(statement) {
+        if (typeof statement === "function")
+            statement = statement();
+        switch (typeof statement) {
+            case "object":
+                if (statement instanceof Array) {
+                    statement = statement.join(",\n");
+                }
+                else {
+                    throw new TypeError("参数 statement 类型错误");
+                }
+                break;
+            case "string":
+                break;
+            default:
+                throw new TypeError("参数 statement 类型错误");
+        }
+        return new InsertChain(this.sql + `\nVALUES\n${statement}`);
+    }
+    select(statement) {
+        if (typeof statement === "function")
+            statement = statement();
+        return new InsertChain(this.sql + `\n${statement}`);
+    }
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            columnsStr = selectColumns(returns);
+        }
+        let sql = this.genSql() + "\nRETURNING " + columnsStr;
+        return new SqlTextStatementDataset(sql);
+    }
+    onConflict(onConflict) {
+        if (typeof onConflict === "function")
+            onConflict = onConflict();
+        if (typeof onConflict !== "string")
+            onConflict = onConflict.join(",");
+        let sql = this.genSql() + `\nON CONFLICT (${onConflict})`;
+        return new InsertAfterOnConflict(sql);
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new InsertChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+class InsertAfterOnConflict {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    doUpdate(set) {
+        if (typeof set === "function")
+            set = set();
+        let sql;
+        switch (typeof set) {
+            case "object": {
+                if (set instanceof Array) {
+                    sql = "\nDO UPDATE SET " + set.join(", ");
+                }
+                else {
+                    sql = "\nDO UPDATE " + createUpdateSetFromObject(set);
+                }
+                break;
+            }
+            case "string":
+                sql = "\nDO UPDATE " + set;
+                break;
+            default:
+                throw new TypeError("参数 set 类型错误");
+        }
+        return new InsertChain(this.sql + sql);
+    }
+    doNotThing() {
+        return new InsertChain(this.sql + " DO NOTHING");
+    }
+    toString() {
+        return this.sql;
+    }
+}
+
+export { InsertChain };

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

@@ -1,38 +1,5 @@
-import { Constructable, TableType } from "../util.ts";
-import { ChainSelect, OrderByParam } from "./select_chain.ts";
+import { SelectSqlGenerator } from "./select_chain.ts";
 /** @public */
-export declare function select(columns?: undefined | ""): ChainSelect<{}>;
-/** @public */
-export declare function select<T extends TableType>(columns: "*"): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<{
-    [key in keyof T]: string | boolean;
-}>): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<string | string[]>): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<string | readonly string[] | {
-    readonly [key in keyof T]: string | boolean;
-}>): ChainSelect<T>;
-/**
- * 生成 ORDER BY 语句
- * @public
- * @example
- * ```ts
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * orderBy() // ""
- *
- * // 以下生成 "\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 },
- *  ]);
- *
- * ```
- */
-export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
+export declare const select: SelectSqlGenerator;
+export { orderBy } from "./select_impl.ts";
 //# sourceMappingURL=select.d.ts.map

package/dist/sql_gen/statement/select.js

@@ -1,154 +1,14 @@
 import { selectColumns } from '../util.js';
-import { selectableToString, whereToString, condition } from '../_statement.js';
-import { SqlTextStatementDataset } from '../SqlStatement.js';
+import { SelectChainAfterSelect } from './select_impl.js';
+export { orderBy } from './select_impl.js';
 
-function select(columns) {
+/** @public */
+const select = function select(columns) {
     if (!columns)
         return new SelectChainAfterSelect("SELECT ");
     if (typeof columns === "function")
         columns = columns();
     return new SelectChainAfterSelect("SELECT " + selectColumns(columns));
-}
-class SelectChainAfterSelect {
-    constructor(sql) {
-        this.#sql = sql;
-    }
-    #sql;
-    from(selectable, option = {}) {
-        let sql = this.#sql + "\nFROM " + selectableToString(selectable, option.as);
-        return new SelectChain(sql);
-    }
-    toString() {
-        return this.#sql;
-    }
-}
-class SelectChain extends SqlTextStatementDataset {
-    constructor(sql) {
-        super(sql);
-    }
-    from(selectable, option = {}) {
-        let sql = this.genSql() + ", " + selectableToString(selectable, option.as);
-        return new SelectChain(sql);
-    }
-    fullJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nFULL JOIN ", selectable, options);
-    }
-    innerJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nINNER JOIN ", selectable, options);
-    }
-    leftJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nLEFT JOIN ", selectable, options);
-    }
-    rightJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nRIGHT JOIN ", selectable, options);
-    }
-    naturalJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nNATURAL JOIN ", selectable, options);
-    }
-    crossJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nCROSS JOIN ", selectable, options);
-    }
-    where(param) {
-        return new SelectChain(this.genSql() + whereToString(param));
-    }
-    groupBy(columns) {
-        let add;
-        if (typeof columns === "string")
-            add = columns;
-        else if (columns)
-            add = columns.join(",");
-        if (!add)
-            return new SelectChain(this.genSql());
-        return new SelectChain(this.genSql() + "\nGROUP BY " + add);
-    }
-    having(param) {
-        return new SelectChain(this.genSql() + havingToString(param));
-    }
-    orderBy(param) {
-        return new SelectChain(this.genSql() + orderBy(param));
-    }
-    limit(limit, offset) {
-        let sql = this.genSql();
-        let type;
-        type = typeof limit;
-        if (type === "number" || type === "bigint")
-            sql += "\nLIMIT " + limit;
-        type = typeof offset;
-        if (type === "number" || type === "bigint")
-            sql += "\nOFFSET " + offset;
-        return new SqlTextStatementDataset(sql);
-    }
-}
-function joinToString(sql, selectable, options = {}) {
-    sql += selectableToString(selectable, options.as);
-    if (options.on) {
-        let on = options.on;
-        if (typeof on === "function")
-            on = on();
-        sql += " ON " + condition(on);
-    }
-    return new SelectChain(sql);
-}
-function havingToString(conditions, type) {
-    const sql = condition(conditions, type);
-    if (sql)
-        return "\nHAVING " + sql;
-    return "";
-}
-/**
- * 生成 ORDER BY 语句
- * @public
- * @example
- * ```ts
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * orderBy() // ""
- *
- * // 以下生成 "\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 },
- *  ]);
- *
- * ```
- */
-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 {
-        sql += "\nORDER BY " + handlerOrderValue(by);
-    }
-    return sql;
-}
-function handlerOrderValue(value) {
-    if (typeof value === "string")
-        return value;
-    let target;
-    if (value.target) {
-        target = value.target;
-    }
-    else {
-        target = value.asc ? "ASC" : "DESC";
-        if (value.nullLast !== undefined)
-            target += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
-    }
-    return value.key + " " + target;
-}
+};
 
-export { orderBy, select };
+export { select };

package/dist/sql_gen/statement/select_chain.d.ts

@@ -1,6 +1,18 @@
 import { ConditionParam, Constructable, TableType } from "../util.ts";
 import { SqlSelectable, SqlStatementDataset } from "../SqlStatement.ts";
 /** @public */
+export interface SelectSqlGenerator {
+    (columns?: undefined | ""): ChainSelect<{}>;
+    <T extends TableType>(columns: "*"): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<{
+        [key in keyof T]: string | boolean;
+    }>): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<string | string[]>): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<string | readonly string[] | {
+        readonly [key in keyof T]: string | boolean;
+    }>): ChainSelect<T>;
+}
+/** @public */
 export type SelectAsNameOption = {
     as?: string;
 };

package/dist/sql_gen/statement/select_impl.d.ts

@@ -0,0 +1,31 @@
+import { Constructable, TableType } from "../util.ts";
+import { SqlSelectable } from "../SqlStatement.ts";
+import { ChainSelectAfterFirstFrom, ChainSelect, SelectAsNameOption, OrderByParam } from "./select_chain.ts";
+export declare class SelectChainAfterSelect<T extends TableType> implements ChainSelect<T> {
+    #private;
+    constructor(sql: string);
+    from(selectable: Constructable<SqlSelectable | string>, option?: SelectAsNameOption): ChainSelectAfterFirstFrom<T>;
+    toString(): string;
+}
+/**
+ * 生成 ORDER BY 语句
+ * @public
+ * @example
+ * ```ts
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * orderBy() // ""
+ *
+ * // 以下生成 "\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 },
+ *  ]);
+ *
+ * ```
+ */
+export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
+//# sourceMappingURL=select_impl.d.ts.map

package/dist/sql_gen/statement/select_impl.js

@@ -0,0 +1,146 @@
+import { selectableToString, whereToString, condition } from '../_statement.js';
+import { SqlTextStatementDataset } from '../SqlStatement.js';
+
+class SelectChainAfterSelect {
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    #sql;
+    from(selectable, option = {}) {
+        let sql = this.#sql + "\nFROM " + selectableToString(selectable, option.as);
+        return new SelectChain(sql);
+    }
+    toString() {
+        return this.#sql;
+    }
+}
+class SelectChain extends SqlTextStatementDataset {
+    constructor(sql) {
+        super(sql);
+    }
+    from(selectable, option = {}) {
+        let sql = this.genSql() + ", " + selectableToString(selectable, option.as);
+        return new SelectChain(sql);
+    }
+    fullJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nFULL JOIN ", selectable, options);
+    }
+    innerJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nINNER JOIN ", selectable, options);
+    }
+    leftJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nLEFT JOIN ", selectable, options);
+    }
+    rightJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nRIGHT JOIN ", selectable, options);
+    }
+    naturalJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nNATURAL JOIN ", selectable, options);
+    }
+    crossJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nCROSS JOIN ", selectable, options);
+    }
+    where(param) {
+        return new SelectChain(this.genSql() + whereToString(param));
+    }
+    groupBy(columns) {
+        let add;
+        if (typeof columns === "string")
+            add = columns;
+        else if (columns)
+            add = columns.join(",");
+        if (!add)
+            return new SelectChain(this.genSql());
+        return new SelectChain(this.genSql() + "\nGROUP BY " + add);
+    }
+    having(param) {
+        return new SelectChain(this.genSql() + havingToString(param));
+    }
+    orderBy(param) {
+        return new SelectChain(this.genSql() + orderBy(param));
+    }
+    limit(limit, offset) {
+        let sql = this.genSql();
+        let type;
+        type = typeof limit;
+        if (type === "number" || type === "bigint")
+            sql += "\nLIMIT " + limit;
+        type = typeof offset;
+        if (type === "number" || type === "bigint")
+            sql += "\nOFFSET " + offset;
+        return new SqlTextStatementDataset(sql);
+    }
+}
+function joinToString(sql, selectable, options = {}) {
+    sql += selectableToString(selectable, options.as);
+    if (options.on) {
+        let on = options.on;
+        if (typeof on === "function")
+            on = on();
+        sql += " ON " + condition(on);
+    }
+    return new SelectChain(sql);
+}
+function havingToString(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
+}
+/**
+ * 生成 ORDER BY 语句
+ * @public
+ * @example
+ * ```ts
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * orderBy() // ""
+ *
+ * // 以下生成 "\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 },
+ *  ]);
+ *
+ * ```
+ */
+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 {
+        sql += "\nORDER BY " + handlerOrderValue(by);
+    }
+    return sql;
+}
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
+    let target;
+    if (value.target) {
+        target = value.target;
+    }
+    else {
+        target = value.asc ? "ASC" : "DESC";
+        if (value.nullLast !== undefined)
+            target += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+    }
+    return value.key + " " + target;
+}
+
+export { SelectChainAfterSelect, orderBy };

package/dist/sql_gen/statement/update.d.ts

@@ -1,17 +1,4 @@
-import { TableType } from "../util.ts";
-import { ChainUpdate } from "./update_chain.ts";
+import { UpdateSqlGenerator } from "./update_chain.ts";
 /** @public */
-export interface UpdateOption {
-    as?: string;
-}
-/**
- * @public
- * @example
- * ```ts
- *  update("table1 AS t").where("t.id = b.id") // UPDATE table1 AS t WHERE t.id = b.id
- *  update("table1",{ as: "t" }).set({ k:"'v'"}) // UPDATE table1 AS t SET t.k = 'v'
- *  update("table1").where("id = 1") // UPDATE table1 AS t WHERE id = 1
- * ```
- */
-export declare function update<T extends TableType>(table: string, options?: UpdateOption): ChainUpdate<T>;
+export declare const update: UpdateSqlGenerator;
 //# sourceMappingURL=update.d.ts.map