@asla/yoursql 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Asnow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+[![ESM package][package]][package-url]
+[![NPM version][npm]][npm-url]
+[![JSR version][jsr]][jsr-url]
+[![Install size][size]][size-url]
+
+[package]: https://img.shields.io/badge/package-ESM-ffe536.svg
+[package-url]: https://nodejs.org/api/esm.html
+[npm]: https://img.shields.io/npm/v/yoursql.svg
+[npm-url]: https://npmjs.com/package/yoursql
+[jsr]: https://jsr.io/badges/@asla/yoursql
+[jsr-url]: https://jsr.io/@asla/yoursql
+[node]: https://img.shields.io/node/v/yoursql.svg
+[node-url]: https://nodejs.org
+[size]: https://packagephobia.com/badge?p=yoursql
+[size-url]: https://packagephobia.com/result?p=yoursql
+
+SQL 生成器
+
+[API 文档](https://jsr.io/@asla/yoursql/doc)

package/dist/mod.d.ts

@@ -0,0 +1,7 @@
+export * from "./sql_value/db_type.ts";
+export * from "./sql_value/sql_value.ts";
+export * from "./select/type.ts";
+export * from "./select/select.ts";
+export * from "./select/selectable.ts";
+export * from "./select/TableQuery.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.js

@@ -0,0 +1,590 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var _SqlRaw_value;
+/**
+ * SQL 原始字符对象
+ * @public
+ */
+class SqlRaw {
+    constructor(value) {
+        _SqlRaw_value.set(this, void 0);
+        __classPrivateFieldSet(this, _SqlRaw_value, value, "f");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _SqlRaw_value, "f");
+    }
+}
+_SqlRaw_value = new WeakMap();
+/**
+ * SQL value 生成器
+ * @public
+ */
+class SqlValuesCreator {
+    /**
+     * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
+     * @example 输入 a'b'c , 返回 a''b''c.
+     */
+    static string(value) {
+        return "'" + value.replaceAll("'", "''") + "'";
+    }
+    /**
+     * @param map - 自定义对象转换
+     */
+    constructor(map = new Map()) {
+        this.map = map;
+    }
+    string(value) {
+        return SqlValuesCreator.string(value);
+    }
+    number(value) {
+        return value.toString();
+    }
+    /** 将 JS 对象转为 SQL 的字符值的形式 */
+    toSqlStr(value) {
+        switch (typeof value) {
+            case "bigint":
+                return this.number(value);
+            case "number":
+                return this.number(value);
+            case "string":
+                return this.string(value);
+            case "boolean":
+                return value.toString();
+            case "object":
+                if (value === null)
+                    return "NULL";
+                if (value instanceof SqlRaw) {
+                    return value.toString();
+                }
+                for (const Class of this.map.keys()) {
+                    if (value instanceof Class)
+                        return this.map.get(Class).call(this, value);
+                }
+                return this.string(JSON.stringify(value));
+            default:
+                let type = typeof value;
+                if (type === "object")
+                    type = value.constructor?.name ?? "object";
+                throw new Error("不支持转换 " + type + " 类型");
+        }
+    }
+    /**
+     * 将对象列表转为 SQL 的 VALUES
+     * @example 返回示例： " (...),(...) "
+     */
+    objectListToValuesList(objectList, keys = Object.keys(objectList[0])) {
+        let i = 0;
+        let j;
+        let value;
+        const rowValues = new Array(objectList.length);
+        try {
+            for (; i < objectList.length; i++) {
+                const object = objectList[i];
+                const values = [];
+                j = 0;
+                for (; j < keys.length; j++) {
+                    value = object[keys[j]];
+                    values[j] = this.toSqlStr(value);
+                }
+                rowValues[i] = "\n(" + values.join(",") + ")";
+            }
+        }
+        catch (error) {
+            let message = error instanceof Error ? error.message : String(error);
+            throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
+        }
+        return rowValues.join(",");
+    }
+    objectToValues(object, keys) {
+        const values = [];
+        let i = 0;
+        let value;
+        try {
+            for (; i < keys.length; i++) {
+                value = object[keys[i]];
+                values[i] = this.toSqlStr(value);
+            }
+        }
+        catch (error) {
+            let message = error instanceof Error ? error.message : String(error);
+            throw new Error("字段 '" + keys[i] + "' 异常，" + message);
+        }
+        return values.join(",");
+    }
+    /**
+     * 将数组列表转为 SQL 的一个 value
+     * @example 返回示例： " 'abc', '6', 'now()' "
+     */
+    toValues(values) {
+        return values.map(this.toSqlStr.bind(this)).join(",");
+    }
+}
+
+/**
+ * @public
+ * PgSql的值转换
+ */
+class PgSqlValue extends SqlValuesCreator {
+    constructor() {
+        const map = new Map();
+        map.set(Array, PgSqlValue.prototype.array);
+        map.set(Date, PgSqlValue.prototype.timestamp);
+        super(map);
+    }
+    timestamp(value) {
+        return SqlValuesCreator.string(value.toISOString());
+    }
+    array(value) {
+        return "ARRAY[" + value.map(this.toSqlStr.bind(this)).join(", ") + "]";
+    }
+}
+
+/** @public */
+class SqlSelectable {
+}
+/** @public */
+class DbTable extends SqlSelectable {
+    constructor(name, columns) {
+        super();
+        this.name = name;
+        if (columns instanceof Array)
+            this.columns = [...columns];
+        else
+            this.columns = Object.keys(columns);
+    }
+    toSelect() {
+        return this.name;
+    }
+    toString() {
+        return this.name;
+    }
+}
+/**
+ * SELECT、UPDATE、DELETE、INSERT INTO 带结果的返回值
+ * @public
+ */
+class SqlQueryStatement extends SqlSelectable {
+    constructor(sql, columns) {
+        super();
+        this.sql = sql;
+        this.columns = columns;
+    }
+    toString() {
+        return this.sql;
+    }
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+}
+
+function genOderBy(orderBy, orderNullRule) {
+    let select = [];
+    let v;
+    for (const key of Object.keys(orderBy)) {
+        v = orderBy[key];
+        switch (v) {
+            case "ASC":
+                break;
+            case "DESC":
+                break;
+            default:
+                throw new Error("orderBy 只能是 ASE 或 DESC. 当前值：" + String(v));
+        }
+        select.push(key + " " + v);
+    }
+    let sql = "\nORDER BY " + select.join(", ");
+    if (orderNullRule) {
+        switch (orderNullRule) {
+            case "FIRST":
+                break;
+            case "LAST":
+                break;
+            default:
+                throw new Error("orderNullRule 只能是 FIRST 或 LAST. 当前值：" + String(orderNullRule));
+        }
+        sql += "NULLS " + orderNullRule;
+    }
+    return 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(", ") };
+}
+/**
+ * @param select  选择的行
+ * @param tableColumns 全部行
+ * @param push 要讲选择的行加入到集合中。
+ */
+function genNewColumns(select, tableColumns, 
+/** newName -> oldName */
+push = new Map()) {
+    if (select === "*") {
+        for (const key of tableColumns) {
+            if (push.has(key))
+                throw new ColumnRepeatError(key);
+            push.set(key, null);
+        }
+    }
+    else {
+        genSelectAsColumns(select, push);
+    }
+    return push;
+}
+function genSelectAsColumns(select, 
+/** newName -> oldName */
+push = new Map()) {
+    if (select instanceof Array) {
+        for (const key of select) {
+            if (push.has(key))
+                throw new ColumnRepeatError(key);
+            push.set(key, null);
+        }
+    }
+    else {
+        let finalName;
+        for (const oldName of Object.keys(select)) {
+            if (typeof select[oldName] === "string")
+                finalName = select[oldName];
+            else if (select[oldName])
+                finalName = oldName;
+            else
+                continue;
+            if (push.has(finalName))
+                throw new ColumnRepeatError(finalName);
+            push.set(finalName, oldName);
+        }
+    }
+    return push;
+}
+class ColumnRepeatError extends Error {
+    constructor(columnName) {
+        super("Column name '" + columnName + "' repeated");
+    }
+}
+
+var _SelectImpl_instances, _a, _SelectImpl_joinOn, _SelectImpl_join;
+/** @public */
+const createSelect = function createSelect(tb, columns, option) {
+    let select = createSelectMap(tb, columns, option).selects;
+    return new SelectImpl(select);
+};
+class SelectImpl extends SqlSelectable {
+    get columns() {
+        return this.getColumns();
+    }
+    *getColumns() {
+        for (const { columns } of this.tableList.values()) {
+            yield* columns.keys();
+        }
+        yield* this.addedColumns.keys();
+    }
+    constructor(tableList, addedColumns = new Map()) {
+        super();
+        _SelectImpl_instances.add(this);
+        this.tableList = tableList;
+        this.addedColumns = addedColumns;
+    }
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+    toString() {
+        let tables = [];
+        let join = "";
+        let selectColumns = [];
+        const size = this.tableList.size;
+        for (const [tableAs, { columns, from, on, type }] of this.tableList) {
+            let tableStr = tableAs === from ? from : from + " AS " + tableAs;
+            if (type) {
+                join += "\n" + type + " " + tableStr;
+                if (on)
+                    join += " ON " + on;
+            }
+            else {
+                tables.push(tableStr);
+            }
+            if (size === 1 && tableAs === from) {
+                for (const [column, oldName] of columns) {
+                    if (!oldName || oldName == column)
+                        selectColumns.push(column);
+                    else
+                        selectColumns.push(oldName + " AS " + column);
+                }
+            }
+            else {
+                for (const [column, oldName] of columns) {
+                    if (!oldName || oldName === column)
+                        selectColumns.push(tableAs + "." + column);
+                    else
+                        selectColumns.push(tableAs + "." + oldName + " AS " + column);
+                }
+            }
+        }
+        for (const [asName, columnStr] of this.addedColumns) {
+            if (asName === columnStr)
+                selectColumns.push(asName);
+            else
+                selectColumns.push(columnStr + " AS " + asName);
+        }
+        if (selectColumns.length === 0)
+            throw new Error("Columns 为空");
+        let sql = `SELECT ${selectColumns.join(", ")}\nFROM ${tables.join(", ")}` + join;
+        return sql;
+    }
+    fullJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "FULL JOIN", tb, columns, option);
+    }
+    innerJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "INNER JOIN", tb, columns, option);
+    }
+    leftJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "LEFT JOIN", tb, columns, option);
+    }
+    rightJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "RIGHT JOIN", tb, columns, option);
+    }
+    naturalJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", tb, columns, option);
+    }
+    crossJoin(tb, columns, option) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", tb, columns, option);
+    }
+    select(tb, columns, option) {
+        let select = createSelectMap(tb, columns, option, this.tableList).selects;
+        const obj = new _a(select, new Map(this.addedColumns));
+        return obj;
+    }
+    addColumns(add) {
+        for (const [asNewName, columnStr] of Object.entries(add)) {
+            if (this.addedColumns.has(asNewName))
+                throw new Error();
+            this.addedColumns.set(asNewName, columnStr);
+        }
+        return this;
+    }
+    toQuery(option = {}) {
+        const { where, orderNullRule } = option;
+        let sql = this.toString();
+        if (where)
+            sql += "\nWHERE " + where;
+        const orderBy = option.orderBy;
+        if (orderBy)
+            sql += genOderBy(orderBy, orderNullRule);
+        if (option.limit)
+            sql += "\nLIMIT " + option.limit;
+        if (option.offset)
+            sql += "\nOFFSET " + option.offset;
+        return new SqlQueryStatement(sql, Array.from(this.columns));
+    }
+}
+_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_joinOn = function _SelectImpl_joinOn(type, tb, columns, option) {
+    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
+    tbInfo.type = type;
+    tbInfo.on = option.on;
+    const next = new _a(selects, new Map(this.addedColumns));
+    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
+    return next;
+}, _SelectImpl_join = function _SelectImpl_join(type, tb, columns, option) {
+    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
+    tbInfo.type = type;
+    const next = new _a(selects, new Map(this.addedColumns));
+    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
+    return next;
+};
+function createSelectMap(tb, columns, option = {}, selects) {
+    let select = new Map(selects);
+    let tableAs;
+    let tbInfo;
+    if (typeof tb === "string") {
+        throw new Error("tb 应是 SqlSelectable 类型");
+        // if (typeof columns !== "object") throw new Error("缺少 option.columns");
+        // const newColumns = genSelectAsColumns(columns);
+        // tableAs = option.tableAs ?? tb;
+        // tbInfo = { table: tb, columns: newColumns };
+    }
+    else {
+        const from = tb.toSelect();
+        if (tb instanceof DbTable) {
+            tableAs = option.tableAs ?? from;
+        }
+        else {
+            tableAs = option.tableAs ?? "t" + select.size;
+        }
+        if (columns) {
+            const newColumns = genNewColumns(columns, tb.columns);
+            tbInfo = { from, columns: newColumns };
+        }
+        else
+            tbInfo = { from, columns: new Map() };
+    }
+    if (select.has(tableAs))
+        throw new TableRepeatError(tableAs);
+    select.set(tableAs, tbInfo);
+    return { selects: select, tbInfo: tbInfo };
+}
+class TableRepeatError extends Error {
+    constructor(tableName) {
+        super("Table name '" + tableName + "' repeated");
+    }
+}
+// interface SqlFrom<T extends object> {
+//   from<A extends object>(table: SqlSelectable<A>): SqlFrom<T & A>;
+// }
+// declare function from<T extends SqlSelectable<any>[]>(...table: T): Select<MergeSelectable<T>>;
+// type MergeSelectable<T extends any[]> = T extends [SqlSelectable<infer P>, ...infer Q] ? P & MergeSelectable<Q> : {};
+
+/** @public */
+class DbTableQuery extends DbTable {
+    constructor(name, columns, statement) {
+        super(name, columns);
+        this.name = name;
+        this.statement = statement;
+    }
+    select(columns, option) {
+        return createSelect(this, columns, option);
+    }
+    insert(values, option) {
+        let insertCol;
+        let valuesStr;
+        if (values instanceof Array) {
+            if (values.length === 0)
+                throw new Error("值不能为空");
+            insertCol = Object.keys(values[0]);
+            valuesStr = `VALUES ${this.statement.objectListToValuesList(values, insertCol)}`;
+        }
+        else if (values instanceof SqlQueryStatement) {
+            // todo 验证 values.columns 和 this.columns 是否匹配
+            valuesStr = values.toSelect();
+            insertCol = values.columns;
+        }
+        else
+            throw new Error("values 应该是 Array 或 TableQuery 类型");
+        if (insertCol.length === 0)
+            throw new Error("插入列不能为空");
+        let sql = `INSERT INTO ${this.name} (${insertCol.join(",")})\n${valuesStr}`;
+        if (option) {
+            const { updateValues, conflict, where } = option;
+            if (conflict) {
+                sql += `\nON CONFLICT (${conflict.join(",")})`;
+                if (updateValues) {
+                    const updateKey = Object.entries(updateValues);
+                    sql += `\nDO UPDATE SET\n${updateKey.map(([key, v = "EXCLUDED." + key]) => key + " = " + v).join(",\n")}`;
+                }
+                else
+                    sql += "DO NOTHING";
+                if (where)
+                    sql += "\nWHERE " + where;
+            }
+        }
+        return sql;
+    }
+    insertWithResult(values, returns, option) {
+        let sql = this.insert(values, option);
+        return genRetuningSql(sql, returns, values instanceof SqlQueryStatement ? values.columns : this.columns);
+    }
+    update(values, option = {}) {
+        const { where } = option;
+        const updateKey = Object.entries(values);
+        if (updateKey.length === 0)
+            throw new Error("值不能为空");
+        let setList = [];
+        for (const [k, v] of updateKey) {
+            if (v === undefined)
+                continue;
+            setList.push(k + " = " + this.statement.toSqlStr(v));
+        }
+        let sql = `UPDATE ${this.name}\nSET ${setList.join(",\n")}`;
+        if (where)
+            sql += genWhere(where);
+        return sql;
+    }
+    updateWithResult(values, returns, option) {
+        let sql = this.update(values, option);
+        return genRetuningSql(sql, returns, values instanceof SqlQueryStatement ? values.columns : this.columns);
+    }
+    delete(option = {}) {
+        let sql = "DELTE FROM " + this.name;
+        if (option.where)
+            sql += genWhere(option.where);
+        return sql;
+    }
+    deleteWithResult(returns = "*", option) {
+        let sql = this.delete(option);
+        return genRetuningSql(sql, returns, this.columns);
+    }
+}
+function genRetuningSql(sql, returns, tableColumns) {
+    let columnsStr;
+    let columns;
+    if (returns === "*") {
+        columns = tableColumns;
+        columnsStr = "*";
+    }
+    else {
+        const res = selectColumnsOrTable(returns);
+        columnsStr = res.sqlColumns;
+        columns = res.columns;
+    }
+    sql += "\nRETURNING " + columnsStr;
+    return new SqlQueryStatement(sql, columns);
+}
+function genWhere(where) {
+    return "\nWHERE " + where;
+}
+
+export { DbTable, DbTableQuery, PgSqlValue, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, createSelect };

package/dist/select/TableQuery.d.ts

@@ -0,0 +1,39 @@
+import { SqlValuesCreator, SqlRaw } from "../sql_value/sql_value.ts";
+import { ColumnsSelected, ColumnsSelectAs, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
+import { Select, SelectTableOption } from "./select.ts";
+import { DbTable, SqlQueryStatement } from "./selectable.ts";
+/** @public */
+export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
+    readonly name: string;
+    private statement;
+    constructor(name: string, columns: readonly string[], statement: SqlValuesCreator);
+    /** 选择全部列 */
+    select(columns?: undefined, option?: SelectTableOption): Select<{}>;
+    /** 选择全部列 */
+    select(columns: "*", option?: SelectTableOption): Select<T>;
+    /** 选择表中的列并重命名 */
+    select<R extends ColumnsSelectAs<T>>(columns: R, option?: SelectTableOption): Select<SelectColumns<T, 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;
+    updateWithResult<R extends ColumnsSelected<T>>(values: UpdateRowValue<T>, returns: R, option?: UpdateOption): SqlQueryStatement<SelectColumns<T, R>>;
+    delete(option?: DeleteOption): string;
+    deleteWithResult<R extends ColumnsSelected<T>>(returns?: ColumnsSelected<T> | "*", option?: DeleteOption): SqlQueryStatement<SelectColumns<T, R>>;
+}
+/** @public */
+export interface InsertOption<T extends object> {
+    conflict?: (keyof T)[];
+    updateValues?: {
+        [key in keyof T]?: undefined | SqlRaw | T[key];
+    };
+    where?: string;
+}
+/** @public */
+export interface UpdateOption {
+    where?: string;
+}
+/** @public */
+export interface DeleteOption {
+    where?: string;
+}
+//# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -0,0 +1,15 @@
+import { ColumnsSelectAs, ColumnsSelected, RowsOrder } from "./type.ts";
+export declare function genOderBy(orderBy: RowsOrder<any>, orderNullRule?: "FIRST" | "LAST"): string;
+export declare function selectColumnsOrTable(columns: ColumnsSelectAs<any> | string[]): {
+    columns: string[];
+    sqlColumns: string;
+};
+/**
+ * @param select  选择的行
+ * @param tableColumns 全部行
+ * @param push 要讲选择的行加入到集合中。
+ */
+export declare function genNewColumns(select: ColumnsSelected<any>, tableColumns: Iterable<string | number | symbol>, 
+/** newName -> oldName */
+push?: Map<string, string | null>): Map<string, string | null>;
+//# sourceMappingURL=_statement.d.ts.map

package/dist/select/select.d.ts

@@ -0,0 +1,55 @@
+import { SqlSelectable, InferQueryResult, SqlQueryStatement } from "./selectable.ts";
+import type { ColumnsSelected, RowsOrder, SelectColumns, TableType } from "./type.ts";
+interface AddTableFn<T extends TableType> {
+    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns?: undefined, option?: SelectTableOption): Select<T>;
+    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option?: SelectTableOption): Select<T & SelectColumns<A, C>>;
+}
+interface JoinTableFn<T extends TableType, ExtraOption extends object = {}> {
+    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns: undefined, option: ExtraOption & SelectTableOption): JoinSelect<T>;
+    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option: ExtraOption & SelectTableOption): JoinSelect<T & SelectColumns<A, C>>;
+}
+/** @public */
+export interface SelectFilterOption<T extends object> {
+    orderBy?: RowsOrder<T>;
+    orderNullRule?: "FIRST" | "LAST";
+    where?: string;
+    offset?: number;
+    limit?: number;
+}
+/** @public */
+export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
+    toQuery(option?: SelectFilterOption<T>): SqlQueryStatement<T>;
+}
+/** @public */
+export interface JoinSelect<T extends TableType> extends FinalSelect<T> {
+    addColumns<A extends TableType>(add: {
+        [key in keyof A]: string;
+    }): FinalSelect<T & A>;
+    crossJoin: JoinTableFn<T>;
+    naturalJoin: JoinTableFn<T>;
+    innerJoin: JoinTableFn<T, {
+        on: string;
+    }>;
+    leftJoin: JoinTableFn<T, {
+        on: string;
+    }>;
+    rightJoin: JoinTableFn<T, {
+        on: string;
+    }>;
+    fullJoin: JoinTableFn<T, {
+        on: string;
+    }>;
+}
+/** @public */
+export interface Select<T extends TableType> extends JoinSelect<T> {
+    /** 选择表 */
+    select: AddTableFn<T>;
+}
+/** @public */
+export declare const createSelect: AddTableFn<{}>;
+/** @public */
+export interface SelectTableOption {
+    tableAs?: string;
+}
+export {};
+//# sourceMappingURL=select.d.ts.map

package/dist/select/selectable.d.ts

@@ -0,0 +1,37 @@
+import { TableType } from "./type.ts";
+declare const SQL_SELECTABLE: unique symbol;
+/** @public */
+export declare abstract class SqlSelectable<T extends TableType> {
+    abstract readonly columns: Iterable<string>;
+    /** select from xxx 中的 xxx */
+    abstract toSelect(): string;
+    abstract toString(): string;
+    /** 保留以推断类型 */
+    [SQL_SELECTABLE]: (item: T) => never;
+}
+/** @public */
+export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
+    readonly name: string;
+    readonly columns: readonly string[];
+    constructor(name: string, columns: readonly (keyof T)[]);
+    toSelect(): string;
+    toString(): string;
+}
+/**
+ * SELECT、UPDATE、DELETE、INSERT INTO 带结果的返回值
+ * @public
+ */
+export declare class SqlQueryStatement<T extends TableType = TableType> extends SqlSelectable<T> {
+    private sql;
+    readonly columns: readonly string[];
+    constructor(sql: string, columns: readonly string[]);
+    toString(): string;
+    toSelect(): string;
+}
+/**
+ * 推断查询结果的类型
+ * @public
+ */
+export type InferQueryResult<T> = T extends SqlSelectable<infer P> ? (P extends TableType ? P : never) : never;
+export {};
+//# sourceMappingURL=selectable.d.ts.map

package/dist/select/type.d.ts

@@ -0,0 +1,55 @@
+import { SqlRaw } from "../sql_value/sql_value.ts";
+/**
+ * @public
+ * @param T - 表格查询类型
+ * @param Rq - 默认选择
+ * @param Pa - 可选选择
+ */
+export type PickColumn<T extends {
+    [key: string]: any;
+}, Rq extends keyof T = keyof T, Pa extends Exclude<keyof T, Rq> = never> = {
+    [key in Rq as null extends T[key] ? key : never]?: T[key];
+} & {
+    [key in Rq as null extends T[key] ? never : key]: T[key];
+} & {
+    [key in Pa]?: T[key];
+};
+/**
+ * 定义行的排序
+ * @public
+ */
+export type RowsOrder<T extends object> = {
+    [key in keyof T]?: OrderValue;
+};
+/** @public */
+export type UpdateRowValue<T extends object> = {
+    [key in keyof T]?: T[key] | SqlRaw;
+};
+/**
+ * 选择列并重命名
+ * @public
+ */
+export type ColumnsSelectAs<T extends TableType> = {
+    [key in keyof T]?: boolean | string;
+};
+/** @public */
+export type OrderValue = "ASC" | "DESC";
+/**
+ * 表的选择参数
+ * @public
+ */
+export type ColumnsSelected<T extends TableType> = ColumnsSelectAs<T> | "*";
+/**
+ * 从一个表格选择列，生成新的表格类型
+ * @public
+ */
+export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends "*" ? T : R extends ColumnsSelectAs<T> ? {
+    [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/sql_value/db_type.d.ts

@@ -0,0 +1,11 @@
+import { SqlValuesCreator } from "./sql_value.ts";
+/**
+ * @public
+ * PgSql的值转换
+ */
+export declare class PgSqlValue extends SqlValuesCreator {
+    constructor();
+    timestamp(value: Date): string;
+    array(value: any[]): string;
+}
+//# sourceMappingURL=db_type.d.ts.map

package/dist/sql_value/sql_value.d.ts

@@ -0,0 +1,51 @@
+declare const SQL_RAW: unique symbol;
+/**
+ * SQL 原始字符对象
+ * @public
+ */
+export declare class SqlRaw<T = any> {
+    #private;
+    constructor(value: string);
+    toString(): string;
+    /** 保留以推断类型 */
+    [SQL_RAW]: (item: T) => never;
+}
+/** @public */
+export type JsObjectMapSql = Map<new (...args: any[]) => any, (value: object) => string>;
+/**
+ * SQL value 生成器
+ * @public
+ */
+export declare class SqlValuesCreator {
+    /**
+     * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
+     * @example 输入 a'b'c , 返回 a''b''c.
+     */
+    static string(value: string): string;
+    /**
+     * @param map - 自定义对象转换
+     */
+    constructor(map?: JsObjectMapSql);
+    private readonly map;
+    string(value: string): string;
+    number(value: number | bigint): string;
+    /** 将 JS 对象转为 SQL 的字符值的形式 */
+    toSqlStr(value: any): string;
+    /**
+     * 将对象列表转为 SQL 的 VALUES
+     * @example 返回示例： " (...),(...) "
+     */
+    objectListToValuesList<T extends object>(objectList: T[], keys?: (keyof T)[]): string;
+    /**
+     * 将对象转为 SQL 的 value
+     * @example 返回示例： " 'abc', '6', 'now()' "
+     */
+    objectToValues(object: object, keys: readonly string[]): string;
+    /**
+     * 将数组列表转为 SQL 的一个 value
+     * @example 返回示例： " 'abc', '6', 'now()' "
+     */
+    toValues(values: readonly any[]): string;
+}
+export {};
+//# sourceMappingURL=sql_value.d.ts.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@asla/yoursql",
+  "version": "0.0.1",
+  "description": "",
+  "type": "module",
+  "types": "./dist/mod.d.ts",
+  "scripts": {
+    "ci:test": "vitest run",
+    "ci:build": "pnpm rollup -c build/rollup.config.js",
+    "build": "pnpm rollup -c  build/rollup.config.js && pnpm run ci:check-api -l",
+    "test": "vitest",
+    "type:check": "tsc",
+    "ci:check-api": "api-extractor run -c api-extractor.jsonc -v"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.47.9",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "rollup": "^4.22.4",
+    "tslib": "^2.7.0",
+    "typescritp": "^1.0.0",
+    "vitest": "^2.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/asnowc/yoursql"
+  },
+  "exports": {
+    ".": "./dist/mod.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*d.ts"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "provenance": true
+  },
+  "keywords": [
+    "sql"
+  ],
+  "author": {
+    "name": "Eavid",
+    "url": "https://github.com/eavidy"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}