@asla/yoursql 0.4.0 → 0.5.1

package/dist/mod.js

@@ -34,6 +34,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
+ * 获取对象数组中的 key 的集合
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
@@ -52,24 +53,59 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
             keys.add(k);
         }
     }
-    return Array.from(keys);
+    return keys;
 }
-/** @public */
-function genWhere(where, type = "AND") {
-    return genWhereHaving(where, "WHERE", type);
+/**
+ * 生成 WHERE 语句
+ * @public
+ * ```ts
+ *
+ * ```
+ */
+function where(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nWHERE " + sql;
+    return "";
 }
-/** @public */
-function genHaving(having, type = "AND") {
-    return genWhereHaving(having, "HAVING", type);
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+function having(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
+}
+function condition(conditions, type = "AND") {
+    if (typeof conditions === "function")
+        conditions = conditions();
+    if (!conditions)
+        return;
+    if (typeof conditions === "string")
+        return conditions;
+    else {
+        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;
+    }
 }
 /**
  * @public
  * ```ts
- * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
- * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
  * ```
  */
-function genSelect(columns) {
+function selectColumns(columns) {
     let sql = "";
     if (columns instanceof Array) {
         if (columns.length)
@@ -101,41 +137,65 @@ function genSelect(columns) {
     }
     return sql;
 }
-/** @public */
-function genOderBy(orderBy) {
-    if (typeof orderBy === "function")
-        orderBy = orderBy();
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * ```ts
+ * // 以下生成 "\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 },
+ *  ]);
+ * orderBy({ age: "DESC NULLS FIRST", num: true });
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * ```
+ */
+function orderBy(by) {
+    if (typeof by === "function")
+        by = by();
     let sql = "";
-    if (typeof orderBy === "string")
-        sql += "\nORDER BY " + orderBy;
-    else if (orderBy instanceof Array) {
-        if (orderBy.length)
-            sql += "\nORDER BY " + orderBy.join(",");
+    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 {
-        let keys = Object.keys(orderBy);
-        if (keys.length)
-            sql += "\nORDER BY " + keys[0] + " " + orderBy[keys[0]];
-        for (let i = 1; i < keys.length; i++) {
-            sql += "," + orderBy[keys[i]] + " " + orderBy[keys[i]];
+        let keys = Object.keys(by);
+        if (keys.length) {
+            let key = keys[0];
+            sql += "\nORDER BY " + key + " " + by[key];
+            for (let i = 1; i < keys.length; i++) {
+                key = keys[i];
+                sql += "," + key + " ";
+                if (typeof by[key] === "string")
+                    sql += by[key];
+                else
+                    sql += by[key] ? "ASC" : "DESC";
+            }
         }
     }
     return sql;
 }
-function genWhereHaving(where, statement, type = "AND") {
-    if (typeof where === "function")
-        where = where();
-    type = " " + type + " ";
-    let sql = "";
-    if (typeof where === "string")
-        sql += "\n" + statement + " " + where;
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
     else {
-        if (where.length)
-            sql += "\n" + statement + " " + +where[0];
-        for (let i = 1; i < where.length; i++)
-            sql += type + where[i];
+        let str = value.key + " " + (value.asc ? "ASC" : "DESC");
+        if (value.nullLast !== undefined)
+            str += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+        return str;
     }
-    return sql;
 }
 
 var _SqlQueryStatement_sql;
@@ -319,7 +379,7 @@ class SqlValuesCreator {
             throw new Error("objectList 不能是空数组");
         let keys;
         if (!keys_types) {
-            keys = getObjectListKeys(objectList, keepUndefinedKey);
+            keys = Array.from(getObjectListKeys(objectList, keepUndefinedKey));
         }
         else if (keys_types instanceof Array) {
             keys = keys_types;
@@ -484,61 +544,76 @@ const pgSqlTransformer = new Map([
     [Date, (value) => SqlValuesCreator.string(value.toISOString())],
 ]);
 
-var _SelectImpl_instances, _a, _SelectImpl_join;
-class FinalSelectImpl extends SqlQueryStatement {
-    constructor(statement) {
-        super(statement);
+var _Selection_instances, _a, _Selection_sql, _Selection_join;
+class AfterSelectImpl extends SqlQueryStatement {
+    constructor(sql, columns) {
+        super(sql, columns);
+    }
+    where(param) {
+        return new AfterSelectImpl(this.toString() + where(param), this.columns);
+    }
+    groupBy(columns) {
+        let sql = this.toString();
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new AfterSelectImpl(sql, this.columns);
     }
-    filter(option) {
-        let { orderBy } = option;
+    having(param) {
+        return new AfterSelectImpl(this.toString() + having(param), this.columns);
+    }
+    orderBy(param) {
+        return new AfterSelectImpl(this.toString() + orderBy(param), this.columns);
+    }
+    limit(limit, offset) {
         let sql = this.toString();
-        if (orderBy)
-            sql += genOderBy(orderBy);
-        if (option.limit)
-            sql += "\nLIMIT " + option.limit;
-        if (option.offset)
-            sql += "\nOFFSET " + option.offset;
+        if (limit)
+            sql += "\nLIMIT " + limit;
+        if (offset)
+            sql += "\nOFFSET " + offset;
         return new SqlQueryStatement(sql, Array.from(this.columns));
     }
 }
-/** @public */
-function createSelect(selectable, as) {
-    return new SelectImpl("FROM " + fromAs(selectable, as));
-}
 function fromAs(selectable, as) {
     let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
     if (as)
         sql += " AS " + as;
     return sql;
 }
-class SelectImpl {
-    constructor(str) {
-        _SelectImpl_instances.add(this);
-        this.str = str;
+/** @public */
+class Selection {
+    static from(selectable, as) {
+        return new this(selectable, as);
+    }
+    constructor(selectable, as) {
+        _Selection_instances.add(this);
+        _Selection_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _Selection_sql, fromAs(selectable, as), "f");
     }
     toString() {
-        return this.str;
+        return "FROM " + __classPrivateFieldGet(this, _Selection_sql, "f");
     }
     fullJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "FULL JOIN", selectable, as, on);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "FULL JOIN", selectable, as, on);
     }
     innerJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "INNER JOIN", selectable, as, on);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "INNER JOIN", selectable, as, on);
     }
     leftJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "LEFT JOIN", selectable, as, on);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "LEFT JOIN", selectable, as, on);
     }
     rightJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "RIGHT JOIN", selectable, as, on);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "RIGHT JOIN", selectable, as, on);
     }
     naturalJoin(selectable, as) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", selectable, as);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "NATURAL JOIN", selectable, as);
     }
     crossJoin(selectable, as) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", selectable, as);
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "CROSS JOIN", selectable, as);
     }
     from(selectable, as) {
-        return new _a(this.str + "," + fromAs(selectable, as));
+        return new _a(__classPrivateFieldGet(this, _Selection_sql, "f") + "," + fromAs(selectable, as));
     }
     select(columnsIn) {
         let sql = "SELECT ";
@@ -546,31 +621,17 @@ class SelectImpl {
         if (typeof columnsIn === "string")
             sql += columnsIn;
         else {
-            sql += genSelect(columnsIn);
+            sql += selectColumns(columnsIn);
             if (columnsIn instanceof Array) ;
             else
                 columns = Object.keys(columnsIn);
         }
-        sql += "\n" + this.str;
-        return new FinalSelectImpl(new SqlQueryStatement(sql, columns));
-    }
-    groupBy(columns) {
-        let sql = this.str;
-        if (typeof columns === "string")
-            sql += " GROUP BY " + columns;
-        else
-            sql += " GROUP BY " + columns.join(",");
-        return new _a(sql);
-    }
-    having(param) {
-        return new _a(this.str + genWhere(param));
-    }
-    where(param) {
-        return new _a(this.str + genWhere(param));
+        sql += "\n" + this.toString();
+        return new AfterSelectImpl(sql, columns);
     }
 }
-_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_join = function _SelectImpl_join(type, selectable, as, on) {
-    let sql = this.str + "\n" + type + " " + fromAs(selectable, as);
+_a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakSet(), _Selection_join = function _Selection_join(type, selectable, as, on) {
+    let sql = __classPrivateFieldGet(this, _Selection_sql, "f") + "\n" + type + " " + fromAs(selectable, as);
     if (on)
         sql += " ON " + on;
     return new _a(sql);
@@ -611,7 +672,10 @@ class DbTableQuery extends DbTable {
         this.statement = statement;
     }
     fromAs(as) {
-        return createSelect(this, as);
+        return new Selection(this, as);
+    }
+    select(columns, as) {
+        return this.fromAs(as).select(columns);
     }
     insert(values, option) {
         let insertCol;
@@ -619,7 +683,7 @@ class DbTableQuery extends DbTable {
         if (values instanceof Array) {
             if (values.length === 0)
                 throw new Error("值不能为空");
-            insertCol = getObjectListKeys(values);
+            insertCol = Array.from(getObjectListKeys(values));
             valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
         }
         else if (values instanceof SqlQueryStatement) {
@@ -653,7 +717,6 @@ class DbTableQuery extends DbTable {
         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("值不能为空");
@@ -664,8 +727,8 @@ class DbTableQuery extends DbTable {
             setList.push(k + " = " + this.statement.toSqlStr(v));
         }
         let sql = `UPDATE ${this.name}\nSET ${setList.join(",\n")}`;
-        if (where)
-            sql += genWhere(where);
+        if (option.where)
+            sql += where(option.where);
         return sql;
     }
     updateWithResult(values, returns, option) {
@@ -675,7 +738,7 @@ class DbTableQuery extends DbTable {
     delete(option = {}) {
         let sql = "DELETE FROM " + this.name;
         if (option.where)
-            sql += genWhere(option.where);
+            sql += where(option.where);
         return sql;
     }
     deleteWithResult(returns = "*", option) {
@@ -870,4 +933,4 @@ class YourTable extends DbTableQuery {
     }
 }
 
-export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, createSelect, genHaving, genOderBy, genSelect, genWhere, getObjectListKeys, pgSqlTransformer };
+export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, where };

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 { JoinSelect } 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): JoinSelect;
+    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,44 +1,43 @@
 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 SelectFilterOption<T extends object> {
-    orderBy?: string | OrderByParam<T> | (() => string | OrderByParam<T>);
-    offset?: number;
-    limit?: number;
+export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
+    limit(limit?: number, offset?: number): SqlQueryStatement<T>;
 }
 /** @public */
-export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
-    filter(option: SelectFilterOption<T>): SqlQueryStatement<T>;
+export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
+    orderBy(param: OrderByParam | (() => OrderByParam | void)): CurrentLimit<T>;
 }
 /** @public */
-export type LastSelect = {
-    select<T extends TableType = TableType>(columns: "*" | string[] | {
-        [key in keyof T]: string | boolean;
-    }): FinalSelect<T>;
-};
-/** @public */
-export type AfterGroup = LastSelect & {
-    having(param: WhereParam | (() => WhereParam)): LastSelect;
-};
-/** @public */
-export type AfterWhere = AfterGroup & {
-    groupBy(columns: string | string[]): AfterGroup;
-};
+export interface CurrentHaving<T extends TableType> extends CurrentOrderBy<T> {
+    having(param: ConditionParam | (() => ConditionParam | void)): CurrentLimit<T>;
+}
 /** @public */
-export type AfterJoin = AfterWhere & {
-    where(param: WhereParam | (() => WhereParam)): AfterWhere;
-};
+export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
+    groupBy(columns: string | string[]): CurrentHaving<T>;
+}
 /** @public */
-export interface JoinSelect extends AfterJoin {
-    from(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
-    crossJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
-    naturalJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
-    innerJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
-    leftJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
-    rightJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
-    fullJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+export interface CurrentWhere<T extends TableType> extends CurrentGroupBy<T> {
+    where(param: ConditionParam | (() => ConditionParam | void)): CurrentGroupBy<T>;
 }
 /** @public */
-export declare function createSelect(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+export declare class Selection {
+    #private;
+    static from(selectable: SqlSelectable<any> | string, as?: string): Selection;
+    constructor(selectable: SqlSelectable<any> | string, as?: string);
+    toString(): string;
+    fullJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    innerJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    leftJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    rightJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    naturalJoin(selectable: SqlSelectable<any>, as?: string | undefined): 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>(columns: {
+        [key in keyof T]: string | boolean;
+    }): CurrentWhere<T>;
+    select(columns: "*" | string[] | Record<string, string | boolean>): CurrentWhere<TableType>;
+}
 //# sourceMappingURL=select.d.ts.map

package/dist/util.d.ts

@@ -1,27 +1,58 @@
 import { OrderValue } from "./select/type.ts";
 /**
+ * 获取对象数组中的 key 的集合
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
-export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): string[];
+export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
 /** @public */
-export type WhereParam = string | string[];
-/** @public */
-export declare function genWhere(where: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
-/** @public */
-export declare function genHaving(having: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+export type ConditionParam = string | string[];
 /**
+ * 生成 WHERE 语句
  * @public
  * ```ts
- * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
- * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ *
  * ```
  */
-export declare function genSelect(columns: string[] | Record<string, string | boolean>): string;
+export declare function where(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+export declare function having(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+/**
+ * @public
+ * ```ts
+ * selectColumns({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+export declare function selectColumns(columns: string[] | Record<string, string | boolean>): string;
 /** @public */
-export type OrderByParam<T extends {} = {}> = string | string[] | ({
-    [key in keyof T]: OrderValue;
-} & Record<string, OrderValue>);
+export type OrderBehavior = {
+    key: string;
+    asc: boolean;
+    nullLast?: boolean;
+};
 /** @public */
-export declare function genOderBy<T extends {} = {}>(orderBy: OrderByParam<T> | (() => OrderByParam<T>)): string;
+export type OrderByParam = string | (string | OrderBehavior)[] | Record<string, boolean | `${OrderValue} ${"NULLS FIRST" | "NULLS LAST"}`>;
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * ```ts
+ * // 以下生成 "\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 },
+ *  ]);
+ * orderBy({ age: "DESC NULLS FIRST", num: true });
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * ```
+ */
+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.4.0",
+  "version": "0.5.1",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",