@asla/yoursql 0.9.3 → 0.10.1

package/dist/sql_gen/statement/delete.js

@@ -0,0 +1,46 @@
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { returningToString, whereToString } from '../_statement.js';
+
+/**
+ * @public
+ * @example
+ * ```ts
+ * deleteFrom("table1").where("id = 1") // DELETE FROM table1 WHERE id = 1
+ * deleteFrom("table1 AS t").where("t.id = 1") // DELETE FROM table1 AS t WHERE t.id = 1
+ * ```
+ */
+function deleteFrom(table, option) {
+    let sql = `DELETE FROM ${table}`;
+    if (option?.as) {
+        sql += ` AS ${option.as}`;
+    }
+    return new DeleteChain(sql);
+}
+class DeleteChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    using(...from) {
+        const textList = from.map((f, i) => {
+            if (typeof f === "function")
+                return f();
+            return f;
+        });
+        const sql = this.genSql() + `\nUSING ${textList.join(", ")}`;
+        return new DeleteChain(sql);
+    }
+    returning(returns) {
+        return new SqlTextStatementDataset(this.genSql() + returningToString(returns));
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new DeleteChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+
+export { deleteFrom };

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

@@ -0,0 +1,26 @@
+import { ConditionParam, Constructable } from "../util.ts";
+import { ChainModifyReturning } from "./_modify.ts";
+/** @public */
+export interface ChainDelete extends ChainDeleteAfterUsing {
+    /**
+     * @example
+     * ```ts
+     *
+     * using("table1 AS b", "(SELECT k FROM table2) AS c").where(...)
+     * // USING table1 AS b, (SELECT k FROM table2) AS c
+     * // WHERE ...
+     * ```
+     */
+    using(...table: (Constructable<string> | {
+        selectable: Constructable<string>;
+        as: string;
+    })[]): ChainDeleteAfterUsing;
+}
+/** @public */
+export interface ChainDeleteAfterUsing extends ChainDeleteReturning {
+    where(where: Constructable<ConditionParam | void>): ChainDeleteReturning;
+}
+/** @public */
+export interface ChainDeleteReturning extends ChainModifyReturning {
+}
+//# sourceMappingURL=delete_chain.d.ts.map

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

@@ -0,0 +1,6 @@
+import { ChainInsert } from "./insert_chain.ts";
+/** @public */
+export declare function insertInto(target: string): ChainInsert;
+/** @public */
+export declare function insertInto(table: string, columns: readonly string[]): ChainInsert;
+//# sourceMappingURL=insert.d.ts.map

package/dist/sql_gen/statement/insert.js

@@ -0,0 +1,107 @@
+import { selectColumns } from '../util.js';
+import { whereToString, createUpdateSetFromObject } from '../_statement.js';
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+
+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

@@ -0,0 +1,28 @@
+import { Constructable } from "../util.ts";
+import { ChainModifyReturning } from "./_modify.ts";
+/** @public */
+export interface ChainAfterConflict {
+    doNotThing(): ChainInsertReturning;
+    doUpdate(set: Constructable<string | readonly string[] | Record<string, string>>): ChainInsertReturning;
+    toString(): string;
+}
+/** @public */
+export interface ChainInsert extends ChainInsertAfterValues {
+    /**
+     * @example
+     * ```ts
+     *  values("(18, 'hi'), (17, 'hh')") // " VALUES(18, 'hi'), (17, 'hh')"
+     *  values(["(18, 'hi')", "(17, 'hh')"]) // " VALUES(18, 'hi'), (17, 'hh')"
+     * ```
+     */
+    values(statement: Constructable<string | readonly string[]>): ChainInsertAfterValues;
+    select(statement: Constructable<string>): ChainInsertAfterValues;
+}
+/** @public */
+export interface ChainInsertAfterValues extends ChainInsertReturning {
+    onConflict(columns: string | string[]): ChainAfterConflict;
+}
+/** @public */
+export interface ChainInsertReturning extends ChainModifyReturning {
+}
+//# sourceMappingURL=insert_chain.d.ts.map

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

@@ -0,0 +1,10 @@
+export * from "./select.ts";
+export * from "./select_chain.ts";
+export * from "./insert.ts";
+export * from "./insert_chain.ts";
+export * from "./update.ts";
+export * from "./update_chain.ts";
+export * from "./delete.ts";
+export * from "./delete_chain.ts";
+export * from "./cte.ts";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1,38 @@
+import { Constructable, TableType } from "../util.ts";
+import { ChainSelect, OrderByParam } 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;
+//# sourceMappingURL=select.d.ts.map

package/dist/sql_gen/statement/select.js

@@ -0,0 +1,154 @@
+import { selectColumns } from '../util.js';
+import { selectableToString, whereToString, condition } from '../_statement.js';
+import { SqlTextStatementDataset } from '../SqlStatement.js';
+
+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 };

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

@@ -0,0 +1,102 @@
+import { ConditionParam, Constructable, TableType } from "../util.ts";
+import { SqlSelectable, SqlStatementDataset } from "../SqlStatement.ts";
+/** @public */
+export type SelectAsNameOption = {
+    as?: string;
+};
+/** @public */
+export interface ChainSelect<T extends TableType> {
+    /**
+     * @example
+     * ```ts
+     * from("table1", {as:"t1"}).from("table2 AS t2") // SELECT ... FROM table1 AS t1 FROM table2 AS t2
+     * ```
+     */
+    from(selectable: Constructable<SqlSelectable | string>, option?: SelectAsNameOption): ChainSelectAfterFirstFrom<T>;
+}
+/** @public */
+export interface ChainSelectAfterFirstFrom<T extends TableType> extends ChainSelectAfterFrom<T> {
+    from(selectable: Constructable<SqlSelectable | string>, option?: SelectAsNameOption): ChainSelectAfterFirstFrom<T>;
+}
+/** @public */
+export type SelectJoinOption = SelectAsNameOption & {
+    on?: Constructable<ConditionParam>;
+};
+/** @public */
+export interface ChainSelectAfterFrom<T extends TableType> extends ChainSelectAfterJoin<T> {
+    innerJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectJoinOption): ChainSelectAfterFrom<T>;
+    leftJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectJoinOption): ChainSelectAfterFrom<T>;
+    rightJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectJoinOption): ChainSelectAfterFrom<T>;
+    fullJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectJoinOption): ChainSelectAfterFrom<T>;
+    naturalJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectAsNameOption): ChainSelectAfterFrom<T>;
+    crossJoin(selectable: Constructable<SqlSelectable | string>, options?: SelectAsNameOption): ChainSelectAfterFrom<T>;
+}
+/** @public */
+export interface ChainSelectAfterJoin<T extends TableType> extends ChainSelectAfterWhere<T> {
+    /**
+     * @example
+     * ```ts
+     * where(undefined) // SELECT ... FROM table1
+     * where([]) // SELECT ... FROM table1
+     * where("age > 18") // SELECT ... FROM table1 WHERE age > 18
+     * where(["age > 18", "name = 'Alice'"]) // SELECT ... FROM table1 WHERE age > 18 AND name = 'Alice'
+     * ```
+     */
+    where(param: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
+}
+/** @public */
+export interface ChainSelectAfterWhere<T extends TableType> extends ChainSelectAfterHaving<T> {
+    /**
+     * @example
+     * ```ts
+     * groupBy("age") // SELECT ... FROM table1 GROUP BY age
+     * groupBy(["age", "name"]) // SELECT ... FROM table1 GROUP BY age, name
+     * ```
+     */
+    groupBy(columns?: string | string[]): ChainSelectAfterGroupBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterGroupBy<T extends TableType> extends ChainSelectAfterHaving<T> {
+    having(param: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
+}
+/** @public */
+export interface ChainSelectAfterHaving<T extends TableType> extends ChainSelectAfterOrderBy<T> {
+    /**
+     * @example
+     * ```ts
+     * orderBy([]) // ""
+     * orderBy({}) // ""
+     * orderBy() // ""
+     * orderBy("age") // ORDER BY age
+     * orderBy(["age DESC", "name ASC NULLS LAST"]) // ORDER BY age DESC, name ASC NULLS LAST
+     * orderBy({key:"age", target:"DESC NULLS LAST"}) // ORDER BY age DESC NULLS LAST
+     * orderBy([{ key: "age", asc: false, nullLast: true }, { key: "name", asc: true }])
+     * // ORDER BY age DESC NULLS LAST, name ASC
+     * ```
+     */
+    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterOrderBy<T extends TableType> extends SqlStatementDataset<T> {
+    limit(limit?: number | bigint, offset?: number | bigint): ChainSelectAfterLimit<T>;
+}
+/** @public */
+export interface ChainSelectAfterLimit<T extends TableType> extends SqlStatementDataset<T> {
+}
+/** @public */
+export type OrderValue = "ASC" | "DESC";
+type OrderByValue = `${OrderValue} NULLS ${"FIRST" | "LAST"}` | OrderValue;
+/** @public */
+export type OrderBehavior = {
+    key: string;
+    asc: boolean;
+    nullLast?: boolean;
+    target?: undefined;
+} | {
+    key: string;
+    target: OrderByValue;
+};
+/** @public */
+export type OrderByParam = string | OrderBehavior | (string | OrderBehavior)[];
+export {};
+//# sourceMappingURL=select_chain.d.ts.map

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

@@ -0,0 +1,17 @@
+import { TableType } from "../util.ts";
+import { ChainUpdate } 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>;
+//# sourceMappingURL=update.d.ts.map

package/dist/sql_gen/statement/update.js

@@ -0,0 +1,88 @@
+import { selectColumns } from '../util.js';
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { createUpdateSetFromObject, whereToString } from '../_statement.js';
+
+/**
+ * @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
+ * ```
+ */
+function update(table, options) {
+    let sql = `UPDATE ${table}`;
+    if (options?.as) {
+        sql += ` AS ${options.as}`;
+    }
+    return new UpdateChain(sql);
+}
+class UpdateChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    from(...from) {
+        const textList = from.map((f, i) => {
+            if (typeof f === "function")
+                return f();
+            return f;
+        });
+        const sql = this.genSql() + `\nFROM ${textList.join(", ")}`;
+        return new UpdateChain(sql);
+    }
+    /**
+     * @example
+     * ```ts
+     * // SET age=3, name='hi', count=b.count
+     * set({age: "3", name: "'hi'", count:"b.count"})
+     * set(["age = 3", "name = 'hi'", "count = b.count"])
+     * set("age = 3, name = 'hi', count = b.count")
+     *
+     * ```
+     */
+    set(values) {
+        if (typeof values === "function")
+            values = values();
+        switch (typeof values) {
+            case "object": {
+                if (values instanceof Array) {
+                    let sql = values.join(", ");
+                    return new UpdateChain(this.sql + " " + sql);
+                }
+                else {
+                    let sql = createUpdateSetFromObject(values);
+                    return new UpdateChain(this.sql + " " + sql);
+                }
+            }
+            case "string":
+                return new UpdateChain(this.sql + " SET\n" + values);
+            default:
+                throw new TypeError("参数 values 类型错误");
+        }
+    }
+    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);
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new UpdateChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+
+export { update };

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

@@ -0,0 +1,36 @@
+import { ConditionParam, Constructable, TableType } from "../util.ts";
+import { ChainModifyReturning } from "./_modify.ts";
+/** @public */
+export interface ChainUpdate<T extends TableType = TableType> {
+    set(value: Constructable<{
+        [key in keyof T]?: string;
+    } | string>): ChainUpdateAfterSet;
+}
+/** @public */
+export interface ChainUpdateAfterSet extends ChainUpdateAfterForm {
+    /**
+     * @example
+     * ```ts
+     *
+     * update({age: "3", name: "'hi'", count:"b.count"}, "a")
+     *  .from("table1 AS b", "(SELECT k FROM table2) AS c")
+     *  .where(...)
+     * // UPDATE table AS a
+     * // FROM table1 AS b, (SELECT k FROM table2) AS c
+     * // SET a.age=3, a.name='hi', a.count=b.count
+     * // WHERE ...
+     * ```
+     */
+    from(...table: (Constructable<string> | {
+        selectable: Constructable<string>;
+        as: string;
+    })[]): ChainUpdateAfterForm;
+}
+/** @public */
+export interface ChainUpdateAfterForm extends ChainUpdateReturning {
+    where(where: Constructable<ConditionParam | void>): ChainUpdateReturning;
+}
+/** @public */
+export interface ChainUpdateReturning extends ChainModifyReturning {
+}
+//# sourceMappingURL=update_chain.d.ts.map