@asla/yoursql 0.6.1 → 0.6.3

package/dist/mod.js

@@ -284,7 +284,7 @@ class SqlQueryStatement extends SqlSelectable {
 }
 _SqlQueryStatement_sql = new WeakMap();
 
-var _SqlValuesCreator_map, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
+var _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
  * @public
@@ -313,20 +313,19 @@ class SqlValuesCreator {
      * @param map - 自定义对象转换
      */
     constructor(map) {
-        _SqlValuesCreator_map.set(this, void 0);
-        __classPrivateFieldSet(this, _SqlValuesCreator_map, new Map(map), "f");
+        this._map = new Map(map);
     }
     setTransformer(type_map, encoder) {
         if (typeof type_map === "function") {
             if (encoder)
-                __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").set(type_map, encoder);
+                this._map.set(type_map, encoder);
             else
-                __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").delete(type_map);
+                this._map.delete(type_map);
         }
         else {
             for (const [type, encoder] of type_map) {
                 if (typeof type === "function" && typeof encoder === "function") {
-                    __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").set(type, encoder);
+                    this._map.set(type, encoder);
                 }
             }
         }
@@ -338,21 +337,28 @@ class SqlValuesCreator {
      *  v() 和 v.toSqlStr() 是等价的
      * ```
      */
-    toSqlStr(value, assertType) {
-        let basicType;
-        if (assertType) {
-            if (typeof assertType === "function") {
-                let type = __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").get(assertType);
-                if (!type)
+    toSqlStr(value, assertJsType) {
+        if (value === null)
+            return "NULL";
+        else if (value === undefined)
+            return "DEFAULT";
+        let basicType = typeof value;
+        if (assertJsType) {
+            if (typeof assertJsType === "function") {
+                if (basicType !== "object")
+                    throw new AssertError("object", basicType);
+                let type = this._map.get(assertJsType);
+                if (!type) {
+                    if (assertJsType === Object)
+                        return this.defaultObject(value);
                     throw new Error("类型不存在");
+                }
                 return type.call(this, value);
             }
-            else {
-                basicType = assertType;
+            else if (basicType !== assertJsType) {
+                throw new AssertError(assertJsType, basicType);
             }
         }
-        else
-            basicType = typeof value;
         switch (basicType) {
             case "bigint":
                 return value.toString();
@@ -363,8 +369,6 @@ class SqlValuesCreator {
             case "boolean":
                 return value.toString();
             case "object": {
-                if (value === null)
-                    return "NULL";
                 if (value instanceof String)
                     return value.toString();
                 return this.getObjectType(value).call(this, value);
@@ -374,17 +378,27 @@ class SqlValuesCreator {
             default:
                 //function、symbol
                 let type = typeof value;
-                throw new Error("不支持转换 " + type + " 类型");
+                throw new Error("不支持 " + type + " 类型");
         }
     }
-    /** 获取值对应的 SqlValueEncoder */
+    /**
+     * @deprecated 已废弃
+     * 获取值对应的 SqlValueEncoder
+     */
     getObjectType(value) {
-        for (const Class of __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").keys()) {
+        for (const Class of this._map.keys()) {
             if (value instanceof Class)
-                return __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").get(Class);
+                return this._map.get(Class);
         }
         return this.defaultObject;
     }
+    /** 获取值对应已定义的类 */
+    getClassType(value) {
+        for (const Class of this._map.keys()) {
+            if (value instanceof Class)
+                return Class;
+        }
+    }
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
     }
@@ -392,6 +406,7 @@ class SqlValuesCreator {
         if (objectList.length <= 0)
             throw new Error("objectList 不能是空数组");
         let keys;
+        let asserts = {};
         if (!keys_types) {
             keys = Array.from(getObjectListKeys(objectList, keepUndefinedKey));
         }
@@ -400,8 +415,9 @@ class SqlValuesCreator {
         }
         else {
             keys = Object.keys(keys_types);
+            asserts = initColumnAssert(keys, keys_types);
         }
-        let str = "(" + this.objectToValues(objectList[0], keys_types ?? keys) + ")";
+        let str = "(" + this._internalObjectToValues(objectList[0], keys, asserts) + ")";
         let i = 1;
         let j;
         let value;
@@ -425,17 +441,37 @@ class SqlValuesCreator {
         return str;
     }
     objectToValues(object, keys_types) {
-        const { keys, type } = toKeyType(object, keys_types);
+        let type = {};
+        let keys;
+        if (keys_types instanceof Array) {
+            keys = keys_types;
+            type = {};
+        }
+        else if (keys_types) {
+            keys = Object.keys(keys_types);
+            type = initColumnAssert(keys, keys_types);
+        }
+        else {
+            keys = Object.keys(object);
+        }
+        return this._internalObjectToValues(object, keys, type);
+    }
+    _internalObjectToValues(object, keys, type) {
         const values = [];
         let i = 0;
         let key;
         let value;
+        let assertType;
         try {
             for (; i < keys.length; i++) {
                 key = keys[i];
                 value = object[key];
-                if (type[key])
-                    values[i] = this.toSqlStr(value) + "::" + type[key];
+                assertType = type[key];
+                if (assertType) {
+                    values[i] = this.toSqlStr(value, assertType.assertJsType);
+                    if (assertType.sqlType)
+                        values[i] += "::" + assertType.sqlType;
+                }
                 else
                     values[i] = this.toSqlStr(value);
             }
@@ -463,24 +499,26 @@ class SqlValuesCreator {
             const column0 = new Array(insertKeys.length);
             let columnName;
             let item;
-            let type;
+            let sqlType;
+            let assertJsType;
             let value;
             for (let i = 0; i < insertKeys.length; i++) {
                 columnName = insertKeys[i];
                 item = valuesTypes[columnName];
                 if (typeof item === "string") {
-                    type = item;
+                    sqlType = item;
                     defaultValues[i] = "NULL";
                 }
                 else {
-                    type = item.sqlType;
+                    sqlType = item.sqlType;
+                    assertJsType = item.assertJsType;
                     defaultValues[i] = item.sqlDefault ?? "NULL";
                 }
                 value = values[0][columnName];
                 if (value === undefined)
-                    column0[i] = defaultValues[i] + "::" + type;
+                    column0[i] = defaultValues[i] + "::" + sqlType;
                 else
-                    column0[i] = this.toSqlStr(value) + "::" + type;
+                    column0[i] = this.toSqlStr(value, assertJsType) + "::" + sqlType;
             }
             valuesStr[0] = "(" + column0.join(",") + ")";
         }
@@ -499,7 +537,6 @@ class SqlValuesCreator {
         return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
     }
 }
-_SqlValuesCreator_map = new WeakMap();
 class YourValuesAs extends SqlSelectable {
     constructor(columns, asName, valuesStr) {
         super();
@@ -518,21 +555,26 @@ class YourValuesAs extends SqlSelectable {
     }
 }
 _YourValuesAs_asName = new WeakMap(), _YourValuesAs_valuesStr = new WeakMap(), _YourValuesAs_sql = new WeakMap();
-function toKeyType(object, keys_types) {
+function initColumnAssert(keys, keys_types) {
+    let key;
+    let value;
     let type = {};
-    let keys;
-    if (keys_types instanceof Array) {
-        keys = keys_types;
-        type = {};
-    }
-    else if (keys_types) {
-        keys = Object.keys(keys_types);
-        type = keys_types;
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        value = keys_types[key];
+        if (typeof value === "string") {
+            type[key] = { sqlType: value };
+        }
+        else {
+            type[key] = value;
+        }
     }
-    else {
-        keys = Object.keys(object);
+    return type;
+}
+class AssertError extends TypeError {
+    constructor(assertType, actual) {
+        super(`Assert ${assertType} type, Actual ${actual} type`);
     }
-    return { type, keys };
 }
 
 /** @public PgSql 转换器 */
@@ -546,17 +588,30 @@ const pgSqlTransformer = new Map([
             let type;
             let basicType;
             for (let i = 0; i < value.length; i++) {
-                {
+                if (value[i] === null || value[i] === undefined)
+                    valueStr[i] = this.toSqlStr(value[i]);
+                else if (type) {
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+                else {
                     basicType = typeof value[i];
-                    if (value[i] === null || basicType === "undefined")
-                        basicType = undefined;
+                    if (basicType === "object") {
+                        type = this.getClassType(value[i]);
+                    }
+                    else
+                        type = basicType;
                     valueStr[i] = this.toSqlStr(value[i], type);
                 }
             }
             return "ARRAY[" + valueStr.join(",") + "]";
         },
     ],
-    [Date, (value) => SqlValuesCreator.string(value.toISOString())],
+    [
+        Date,
+        function (value) {
+            return SqlValuesCreator.string(value.toISOString());
+        },
+    ],
 ]);
 
 var _Selection_instances, _a, _Selection_sql, _Selection_join;

package/dist/sql_value/sql_value.d.ts

@@ -13,21 +13,26 @@ export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
 export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T) => string;
 /** @public 断言类型 */
-export type ManualType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
+export type AssertJsType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
+/**
+ * @deprecated 改用 AssertJsType
+ * @public 断言类型
+ */
+export type ManualType = AssertJsType;
 /** @public */
 export type SqlValueFn = SqlValuesCreator & {
     /**
      * 安全将 JS 对象转为 SQL 的字符值的形式，可避免 SQL 注入。
      * undefined 将被转换为 DEFAULT
+     * @param assertType - 如果断言了基本类型，并且值的基本类型与断言的类型不一致，则会抛出异常。 如果不是基本类型，则 value 会被传递给指定的转义器
      */
-    (value: any, assertType?: ManualType): string;
+    (value: any, assertType?: AssertJsType): string;
 };
 /**
  * SQL value 生成器
  * @public
  */
 export declare class SqlValuesCreator {
-    #private;
     static create(map?: JsObjectMapSql): SqlValueFn;
     /**
      * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
@@ -41,6 +46,7 @@ export declare class SqlValuesCreator {
     /** 设置转换器 */
     setTransformer(type: new (...args: any[]) => any, encoder?: SqlValueEncoder): void;
     setTransformer(map: JsObjectMapSql): void;
+    private readonly _map;
     /**
      * 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT
      * ```ts
@@ -48,9 +54,14 @@ export declare class SqlValuesCreator {
      *  v() 和 v.toSqlStr() 是等价的
      * ```
      */
-    toSqlStr(value: any, assertType?: ManualType): string;
-    /** 获取值对应的 SqlValueEncoder */
+    toSqlStr(value: any, assertJsType?: AssertJsType): string;
+    /**
+     * @deprecated 已废弃
+     * 获取值对应的 SqlValueEncoder
+     */
     getObjectType(value: object): SqlValueEncoder;
+    /** 获取值对应已定义的类 */
+    getClassType(value: object): undefined | (new (...args: unknown[]) => unknown);
     protected defaultObject(value: object): string;
     /**
      * 将对象列表转为 SQL 的 VALUES。
@@ -58,7 +69,7 @@ export declare class SqlValuesCreator {
      * @param keys - 选择的键。如果指定了 keys, 值为 undefined 的属性将自动填充为 null; 如果未指定 keys，将选择 objectList 所有不是 undefined 项的键的并集
      */
     objectListToValuesList<T extends object>(objectList: T[], keys?: readonly (keyof T)[] | {
-        [key in keyof T]?: string | undefined;
+        [key in keyof T]?: string | undefined | ColumnToValueConfig;
     }, keepUndefinedKey?: boolean): string;
     /**
      * 将对象转为 SQL 的 value
@@ -66,8 +77,9 @@ export declare class SqlValuesCreator {
      * @param keys - 如果指定了key, object undefined 的属性值将填充为 null，如果不指定，将自获取 object 所有非 undefined 的属性的key
      */
     objectToValues<T extends object>(object: T, keys?: readonly (keyof T)[] | {
-        [key in keyof T]?: string | undefined;
+        [key in keyof T]?: string | undefined | ColumnToValueConfig;
     }): string;
+    private _internalObjectToValues;
     /**
      * 将数组列表转为 SQL 的一个 value
      * @example 返回示例： " 'abc', '6', 'now()' "
@@ -88,7 +100,13 @@ export declare class SqlValuesCreator {
     createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | {
         sqlType: string;
         sqlDefault?: string;
+        assertJsType?: AssertJsType;
     }>): SqlSelectable<T>;
 }
+/** @public */
+export type ColumnToValueConfig = {
+    sqlType?: string;
+    assertJsType?: AssertJsType;
+};
 export {};
 //# sourceMappingURL=sql_value.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",