@asla/yoursql 0.8.2 → 0.8.4

package/dist/sql_gen/util.js

@@ -0,0 +1,166 @@
+import { condition } from './select/_statement.js';
+
+/**
+ * 获取对象数组中的 key 的集合
+ * @public
+ * @param keepUndefinedKey - 是否保留值为 undefined 的 key
+ */
+function getObjectListKeys(objectList, keepUndefinedKey) {
+    let keys = new Set();
+    for (let i = 0; i < objectList.length; i++) {
+        let obj = objectList[i];
+        let hasKeys = Object.keys(obj);
+        let k;
+        for (let j = 0; j < hasKeys.length; j++) {
+            k = hasKeys[j];
+            if (typeof k !== "string")
+                continue;
+            if (!keepUndefinedKey && obj[k] === undefined)
+                continue;
+            keys.add(k);
+        }
+    }
+    return keys;
+}
+/**
+ * 生成 WHERE 语句
+ * @public
+ * @example
+ * ```ts
+ * where(['a=1','b=2']) // "\nWHERE a=1 AND b=2"
+ * where(['a=1','b=2'],"OR") // "\nWHERE a=1 OR b=2"
+ * where("a=1 OR b=2") // "\nWHERE a=1 OR b=2"
+ * where(()=>"a=1 OR b=2") // "\nWHERE a=1 AND b=2"
+ * where([]) // ""
+ * where(undefined) // ""
+ * ```
+ */
+function where(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nWHERE " + sql;
+    return "";
+}
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+function having(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
+}
+/**
+ * @public
+ * @example
+ * ```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"
+ * ```
+ */
+function selectColumns(columns) {
+    if (typeof columns === "function")
+        columns = columns();
+    switch (typeof columns) {
+        case "string":
+            return columns;
+        case "object": {
+            if (columns instanceof Array) {
+                if (columns.length === 0)
+                    throw new Error("没有选择任何列");
+                return columns.join(",");
+            }
+            else {
+                let sql = "";
+                const keys = Object.keys(columns);
+                if (keys.length === 0)
+                    throw new Error("没有选择任何列");
+                let k = keys[0];
+                let v = columns[k];
+                if (typeof v === "string")
+                    sql += v + " AS " + k;
+                else
+                    sql += k;
+                for (let i = 1; i < keys.length; i++) {
+                    k = keys[i];
+                    v = columns[k];
+                    sql += ",";
+                    if (typeof v === "string")
+                        sql += v + " AS " + k;
+                    else
+                        sql += k;
+                }
+                return sql;
+            }
+        }
+        default:
+            throw new TypeError("columns 应为 string 或 object 类型");
+    }
+}
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * @example
+ * ```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 (!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(by);
+        if (keys.length) {
+            let key = keys[0];
+            let value = by[key];
+            sql += "\nORDER BY " + key + " " + (typeof value === "string" ? value : value ? "ASC" : "DESC");
+            for (let i = 1; i < keys.length; i++) {
+                key = keys[i];
+                value = by[key];
+                sql += "," + key + " ";
+                if (typeof value === "string")
+                    sql += value;
+                else
+                    sql += value ? "ASC" : "DESC";
+            }
+        }
+    }
+    return sql;
+}
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
+    else {
+        let str = value.key + " " + (value.asc ? "ASC" : "DESC");
+        if (value.nullLast !== undefined)
+            str += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+        return str;
+    }
+}
+
+export { getObjectListKeys, having, orderBy, selectColumns, where };

package/dist/sql_gen/your_table/checker.js

@@ -0,0 +1,82 @@
+import { CustomDbType } from './infer_db_type.js';
+
+/** @public */
+class TypeChecker {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    check(value) {
+        const map = this.map;
+        let v;
+        for (const [k, expect] of map) {
+            v = value[k];
+            let err;
+            if (v === null) {
+                if (expect.notNull)
+                    throw new Error(`${k} 不能为空`);
+                continue;
+            }
+            else if (v === undefined) {
+                if (expect.sqlDefault === undefined && expect.notNull)
+                    throw new Error(`${k} 不能为 undefined`);
+                continue;
+            }
+            else if (expect.isArray) {
+                if (v instanceof Array)
+                    err = this.checkArray(v, expect.type);
+                else
+                    err = getErrStr(`Array<${expect.type.name}>`, typeof v);
+            }
+            else {
+                err = this.checkItem(v, expect.type);
+            }
+            if (err)
+                throw new Error(`Key ${k} error: ${err}`);
+        }
+        return value;
+    }
+    checkList(value) {
+        let i = 0;
+        try {
+            for (let i = 0; i < value.length; i++) {
+                this.check(value[i]);
+            }
+            return value;
+        }
+        catch (error) {
+            throw new Error(`Item ${i}, ${error.message}`);
+        }
+    }
+    checkArray(v, expect) {
+        let err;
+        for (let i = 0; i < v.length; i++) {
+            err = this.checkItem(v[i], expect);
+            if (err)
+                return `Item[${i}] ${err}`;
+        }
+    }
+    checkItem(v, expect) {
+        if (expect instanceof CustomDbType) {
+            if (expect.is(v))
+                return;
+        }
+        else {
+            if (v instanceof expect)
+                return;
+        }
+        let actName = typeof v;
+        if (actName === "object") {
+            if (v === null)
+                actName = "null";
+            else
+                actName = v.constructor?.name ?? "object";
+        }
+        return getErrStr(expect.name, typeof v);
+    }
+}
+function getErrStr(expect, actual) {
+    return `Expect ${expect}, Actual ${actual}`;
+}
+
+export { TypeChecker };

package/dist/sql_gen/your_table/infer_db_type.js

@@ -0,0 +1,76 @@
+/**
+ * 表格列的信息
+ * @public
+ */
+class ColumnMeta {
+    type;
+    sqlType;
+    notNull;
+    isArray;
+    sqlDefault;
+    constructor(type, 
+    /** 数据库原始数据类型 */
+    sqlType, 
+    /** 是否非空 */
+    notNull = false, 
+    /** 是否是数组类型 */
+    isArray = false, 
+    /** 数据库原始默认值 */
+    sqlDefault) {
+        this.type = type;
+        this.sqlType = sqlType;
+        this.notNull = notNull;
+        this.isArray = isArray;
+        this.sqlDefault = sqlDefault;
+    }
+    /** 校验 value 的类型 */
+    checkValue(value) {
+        if (typeof this.type === "function")
+            return value instanceof this.type;
+        return this.type.is(value);
+    }
+}
+/**
+ * 数据库类型到JS类型的映射
+ * @public
+ */
+class YourTypeMap {
+    typeMap;
+    static create(rawTypeMap) {
+        return new this(rawTypeMap);
+    }
+    constructor(typeMap = {}) {
+        this.typeMap = typeMap;
+    }
+    genColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type, notNull, false, defaultValue);
+        return column;
+    }
+    genArrColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type + "[]", notNull, true, defaultValue);
+        return column;
+    }
+}
+function baseType(v) {
+    return typeof v === this.name;
+}
+/**
+ * 自定义数据类型
+ * @public
+ */
+class CustomDbType {
+    is;
+    name;
+    static bigint = new CustomDbType(baseType, "bigint");
+    static number = new CustomDbType(baseType, "number");
+    static string = new CustomDbType(baseType, "string");
+    static boolean = new CustomDbType(baseType, "boolean");
+    constructor(is, name) {
+        this.is = is;
+        this.name = name;
+    }
+}
+
+export { ColumnMeta, CustomDbType, YourTypeMap };

package/dist/sql_gen/your_table/table.js

@@ -0,0 +1,33 @@
+import { DbTableQuery } from '../select/TableQuery.js';
+import { TypeChecker } from './checker.js';
+
+/**
+ * 完整数据库表数据
+ * @public
+ */
+class YourTable extends DbTableQuery {
+    define;
+    constructor(name, define, sqlValue) {
+        super(name, sqlValue);
+        this.define = define;
+        this.columns = Object.keys(define);
+    }
+    columns;
+    getColumnMeta(name) {
+        return Reflect.get(this.define, name);
+    }
+    createTypeChecker(keys) {
+        let map = new Map();
+        let defined = this.define;
+        let k;
+        for (let i = 0; i < keys.length; i++) {
+            k = keys[i];
+            if (defined[k] === undefined)
+                throw new Error(`key ${k} 未定义`);
+            map.set(k, defined[k]);
+        }
+        return new TypeChecker(map);
+    }
+}
+
+export { YourTable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
@@ -29,8 +29,8 @@
     "url": "https://github.com/asnowc/yoursql"
   },
   "exports": {
-    ".": "./dist/sql_gen.js",
-    "./client": "./dist/client.js"
+    ".": "./dist/sql_gen/mod.js",
+    "./client": "./dist/client/mod.js"
   },
   "files": [
     "dist/**/*.js",

package/dist/client.js

@@ -1,209 +0,0 @@
-/** @public */
-class ParallelQueryError extends Error {
-    constructor() {
-        super("The previous query was not completed and cannot be executed");
-    }
-}
-/** @public */
-class ConnectionNotAvailableError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-
-/**
- * SQL 查询相关操作
- * @public
- */
-class DbQuery {
-    /** 单语句查询受影响的行 */
-    queryCount(sql) {
-        return this.query(sql.toString()).then((res) => {
-            if (res.rowCount === null)
-                return 0;
-            return res.rowCount;
-        });
-    }
-    queryRows(sql) {
-        return this.query(sql.toString()).then((res) => res.rows);
-    }
-    multipleQueryRows(sql) {
-        return this.multipleQuery(sql.toString()).then((res) => res.map((item) => item.rows ?? []));
-    }
-    async queryMap(sql, key) {
-        const { rows } = await this.query(sql.toString());
-        let map = new Map();
-        for (let i = 0; i < rows.length; i++) {
-            map.set(rows[i][key], rows[i]);
-        }
-        return map;
-    }
-}
-
-/** @public */
-class DbCursor {
-    // implement
-    [Symbol.asyncDispose]() {
-        return this.close();
-    }
-    async *[Symbol.asyncIterator]() {
-        let data = await this.read();
-        try {
-            while (data.length) {
-                yield* data;
-                data = await this.read();
-            }
-        }
-        finally {
-            await this.close();
-        }
-    }
-}
-
-/**
-
-/**
- * 池连接
- * @public
- */
-class DbPoolConnection extends DbQuery {
-    constructor(conn, onRelease) {
-        super();
-        this.#conn = conn;
-        this.#onRelease = onRelease;
-    }
-    #onRelease;
-    //implement
-    async begin(mode) {
-        await this.query("BEGIN" + (mode ? " TRANSACTION ISOLATION LEVEL " + mode : ""));
-    }
-    #conn;
-    query(sql) {
-        if (!this.#conn)
-            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
-        return this.#conn.query(sql);
-    }
-    multipleQuery(sql) {
-        if (!this.#conn)
-            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
-        return this.#conn.multipleQuery(sql);
-    }
-    //implement
-    async rollback() {
-        await this.query("ROLLBACK");
-    }
-    //implement
-    async commit() {
-        await this.query("COMMIT");
-    }
-    get released() {
-        return !this.#conn;
-    }
-    /** 调用 release() 时，如果事务未提交，则抛出异常 */
-    release() {
-        if (this.#conn) {
-            this.#conn = undefined;
-            this.#onRelease();
-        }
-    }
-    //implement
-    [Symbol.dispose]() {
-        return this.release();
-    }
-}
-
-/**
- * @public
- * 池连接事务
- */
-class DbPoolTransaction extends DbQuery {
-    mode;
-    constructor(connect, mode) {
-        super();
-        this.mode = mode;
-        this.#query = (sql) => {
-            return new Promise((resolve, reject) => {
-                this.#pending = connect()
-                    .then((conn) => {
-                    this.#conn = conn;
-                    const promise = conn.multipleQuery("BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "") + ";\n" + sql);
-                    this.#pending = promise;
-                    this.#query = this.#queryAfter;
-                    return promise;
-                })
-                    .then((res) => {
-                    this.#pending = undefined;
-                    resolve(res[1]);
-                }, (e) => {
-                    this.#pending = undefined;
-                    reject(e);
-                    if (this.#conn)
-                        this.#release(this.#conn, e);
-                });
-            });
-        };
-    }
-    #pending;
-    #conn;
-    async commit() {
-        if (this.#pending)
-            throw new ParallelQueryError();
-        if (this.#conn) {
-            const promise = this.#conn.query("COMMIT");
-            this.#release(this.#conn);
-            await promise;
-        }
-    }
-    async rollback() {
-        if (this.#pending)
-            throw new ParallelQueryError();
-        if (this.#conn) {
-            const promise = this.#conn.query("ROLLBACK");
-            this.#release(this.#conn);
-            await promise;
-        }
-    }
-    savePoint(savePoint) {
-        return this.query("SAVEPOINT" + savePoint).then(() => { });
-    }
-    rollbackTo(savePoint) {
-        return this.query("ROLLBACK TO " + savePoint).then(() => { });
-    }
-    /** 拿到连接后执行这个 */
-    #queryAfter(sql) {
-        return this.#conn.query(sql).then((res) => {
-            this.#pending = undefined;
-            return res;
-        }, (e) => {
-            this.#pending = undefined;
-            this.#release(this.#conn, e);
-            throw e;
-        });
-    }
-    #query;
-    query(sql) {
-        if (this.#pending)
-            return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
-    }
-    multipleQuery(sql) {
-        if (this.#pending)
-            return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
-    }
-    #error;
-    #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {
-        this.#error = error;
-        this.#query = () => Promise.reject(this.#error);
-        this.#conn = undefined;
-        conn.release();
-    }
-    get released() {
-        return !!this.#error;
-    }
-    [Symbol.asyncDispose]() {
-        return this.rollback();
-    }
-}
-
-export { ConnectionNotAvailableError, DbCursor, DbPoolConnection, DbPoolTransaction, DbQuery, ParallelQueryError };

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

@@ -1,91 +0,0 @@
-import { ConditionParam, Constructable, OrderByParam, SelectParam } from "../util.ts";
-import { TableType } from "./type.ts";
-/** @public */
-export declare abstract class SqlStatement {
-    /** 获取 SQL 语句 */
-    abstract toString(): string;
-}
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlStatementDataset
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-export interface SqlSelectable {
-    /**
-     * 转成子选择语句, 你可以使用 select form xxx 选择
-     * 如果是 table 则是 table name
-     * 如果是 选择语句，则是 (xxx)
-     */
-    toSelect(): string;
-}
-/** @public */
-export declare abstract class SqlStatementDataset<T> extends SqlStatement implements SqlSelectable {
-    /**
-     * 转成子选择语句, 你可以使用 select form xxx 选择
-     * 如果是 table 则是 table name
-     * 如果是 选择语句，则是 (xxx)
-     */
-    toSelect(): string;
-}
-/** @public */
-export interface ChainSelectLimit<T extends TableType> extends SqlStatementDataset<T> {
-    limit(limit?: number | bigint, offset?: number | bigint): SqlStatementDataset<T>;
-}
-/** @public */
-export interface ChainSelectOrderBy<T extends TableType> extends ChainSelectLimit<T> {
-    orderBy(param: Constructable<OrderByParam | void>): ChainSelectLimit<T>;
-}
-/** @public */
-export interface ChainSelectHaving<T extends TableType> extends ChainSelectOrderBy<T> {
-    having(param: Constructable<ConditionParam | void>): ChainSelectLimit<T>;
-}
-/** @public */
-export interface ChainSelectGroupBy<T extends TableType> extends ChainSelectOrderBy<T> {
-    groupBy(columns: string | string[]): ChainSelectHaving<T>;
-}
-/** @public */
-export interface ChainSelectWhere<T extends TableType> extends ChainSelectGroupBy<T> {
-    where(param: Constructable<ConditionParam | void>): ChainSelectGroupBy<T>;
-}
-/** @public */
-export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
-    returning(columns: "*"): SqlStatementDataset<T>;
-    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
-}
-/** @public */
-export interface ChainModifyWhere<T extends TableType = {}> extends ChainModifyReturning<T> {
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-}
-/** @public */
-export interface ChainConflictDo<T extends TableType = {}> {
-    doNotThing(): ChainModifyReturning<T>;
-    /**
-     * 需要注意 SQL 注入
-     */
-    doUpdate(set: Constructable<string | {
-        [key in keyof T]?: string;
-    }>): ChainModifyWhere<T>;
-    toString(): string;
-}
-/** @public */
-export interface ChainOnConflict<T extends TableType = {}> extends ChainModifyReturning<T> {
-    onConflict(option: Constructable<readonly (keyof T)[] | string>): ChainConflictDo<T>;
-}
-/** @public */
-export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
-    readonly sql: string;
-    constructor(sql: string);
-    toString(): string;
-}
-/**
- * 推断查询结果的类型
- * @public
- */
-export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
-//# sourceMappingURL=query_chain_abstract.d.ts.map