@asla/yoursql 0.2.0 → 0.3.1

package/dist/mod.d.ts

@@ -5,4 +5,5 @@ export * from "./select/select.ts";
 export * from "./select/selectable.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
+export * from "./your_table/mod.ts";
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.js

@@ -55,7 +55,79 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
     return Array.from(keys);
 }
 
-var _SqlRaw_value;
+/**
+ * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
+ * @example
+ * ```ts
+ * declare const item: SqlSelectable<any>
+ * await query(`select * from ${item.toSelect()}`)
+ *
+ * ```
+ * @public
+ */
+class SqlSelectable {
+    constructor(columns) {
+        // Reflect.set(this, SQL_SELECTABLE, undefined);
+        let readonlyColumns;
+        if (typeof columns[Symbol.iterator] === "function") {
+            let iterable = columns;
+            readonlyColumns = [];
+            let iter = iterable[Symbol.iterator]();
+            let i = 0;
+            let item = iter.next();
+            while (!item.done) {
+                readonlyColumns[i++] = item.value;
+                item = iter.next();
+            }
+            // readonlyColumns.length = i;
+        }
+        else {
+            let arrayLike = columns;
+            readonlyColumns = new Array(arrayLike.length);
+            // readonlyColumns.length = arrayLike.length;
+            for (let i = 0; i < arrayLike.length; i++) {
+                readonlyColumns[i] = arrayLike[i];
+            }
+        }
+        this.columns = readonlyColumns;
+    }
+}
+/**
+ * 数据库表
+ * @public
+ */
+class DbTable extends SqlSelectable {
+    constructor(name, columns) {
+        if (!(columns instanceof Array))
+            columns = Object.keys(columns);
+        super(columns);
+        this.name = name;
+    }
+    toSelect() {
+        return this.name;
+    }
+    toString() {
+        return this.name;
+    }
+}
+/**
+ * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
+ * @public
+ */
+class SqlQueryStatement extends SqlSelectable {
+    constructor(sql, columns) {
+        super(columns);
+        this.sql = sql;
+    }
+    toString() {
+        return this.sql;
+    }
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+}
+
+var _SqlRaw_value, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
  * SQL 原始字符对象
  * @public
@@ -106,7 +178,10 @@ class SqlValuesCreator {
         let basicType;
         if (expectType) {
             if (typeof expectType === "function") {
-                return this.map.get(expectType).call(this, value, this.map);
+                let type = this.map.get(expectType);
+                if (!type)
+                    throw new Error("类型不存在");
+                return type.call(this, value);
             }
             else {
                 basicType = expectType;
@@ -123,8 +198,13 @@ class SqlValuesCreator {
                 return SqlValuesCreator.string(value);
             case "boolean":
                 return value.toString();
-            case "object":
-                return this.toObjectStr(value);
+            case "object": {
+                if (value === null)
+                    return "NULL";
+                if (value instanceof SqlRaw)
+                    return value.toString();
+                return this.getObjectType(value).call(this, value);
+            }
             case "undefined":
                 return "DEFAULT";
             default:
@@ -133,16 +213,13 @@ class SqlValuesCreator {
                 throw new Error("不支持转换 " + type + " 类型");
         }
     }
-    toObjectStr(value) {
-        if (value === null)
-            return "NULL";
-        if (value instanceof SqlRaw)
-            return value.toString();
+    /** 获取值对应的 SqlValueEncoder */
+    getObjectType(value) {
         for (const Class of this.map.keys()) {
             if (value instanceof Class)
-                return this.map.get(Class).call(this, value, this.map);
+                return this.map.get(Class);
         }
-        return this.defaultObject(value);
+        return this.defaultObject;
     }
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
@@ -212,7 +289,70 @@ class SqlValuesCreator {
     toValues(values) {
         return values.map((v) => this.toSqlStr(v)).join(",");
     }
+    createValues(asName, values, valuesTypes) {
+        if (values.length === 0)
+            throw new Error("values 不能为空");
+        const insertKeys = Object.keys(valuesTypes);
+        const defaultValues = [];
+        const valuesStr = new Array(values.length);
+        {
+            const column0 = new Array(insertKeys.length);
+            let columnName;
+            let item;
+            let type;
+            let value;
+            for (let i = 0; i < insertKeys.length; i++) {
+                columnName = insertKeys[i];
+                item = valuesTypes[columnName];
+                if (typeof item === "string") {
+                    type = item;
+                    defaultValues[i] = "NULL";
+                }
+                else {
+                    type = item.sqlType;
+                    defaultValues[i] = item.sqlDefault ?? "NULL";
+                }
+                value = values[0][columnName];
+                if (value === undefined)
+                    column0[i] = defaultValues[i] + "::" + type;
+                else
+                    column0[i] = this.toSqlStr(value) + "::" + type;
+            }
+            valuesStr[0] = "(" + column0.join(",") + ")";
+        }
+        let items = new Array(insertKeys.length);
+        let value;
+        for (let i = 1; i < values.length; i++) {
+            for (let j = 0; j < insertKeys.length; j++) {
+                value = values[i][insertKeys[j]];
+                if (value === undefined)
+                    items[j] = defaultValues[j];
+                else
+                    items[j] = this.toSqlStr(value);
+            }
+            valuesStr[i] = "(" + items.join(",") + ")";
+        }
+        return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
+    }
 }
+class YourValuesAs extends SqlSelectable {
+    constructor(columns, asName, valuesStr) {
+        super(columns);
+        _YourValuesAs_asName.set(this, void 0);
+        _YourValuesAs_valuesStr.set(this, void 0);
+        _YourValuesAs_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _YourValuesAs_asName, asName, "f");
+        __classPrivateFieldSet(this, _YourValuesAs_valuesStr, valuesStr, "f");
+        __classPrivateFieldSet(this, _YourValuesAs_sql, `(VALUES\n${__classPrivateFieldGet(this, _YourValuesAs_valuesStr, "f")})\nAS ${__classPrivateFieldGet(this, _YourValuesAs_asName, "f")}(${this.columns.join(",")})`, "f");
+    }
+    toSelect() {
+        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+    }
+}
+_YourValuesAs_asName = new WeakMap(), _YourValuesAs_valuesStr = new WeakMap(), _YourValuesAs_sql = new WeakMap();
 function toKeyType(object, keys_types) {
     let type = {};
     let keys;
@@ -235,90 +375,25 @@ const pgSqlTransformer = new Map([
     [
         Array,
         function encodePgArray(value) {
-            return ("ARRAY[" +
-                value
-                    .map(function (item) {
-                    return this.toSqlStr(item);
-                })
-                    .join(", ") +
-                "]");
+            if (value.length === 0)
+                return "NULL";
+            const valueStr = [];
+            let type;
+            let basicType;
+            for (let i = 0; i < value.length; i++) {
+                {
+                    basicType = typeof value[i];
+                    if (value[i] === null || basicType === "undefined")
+                        basicType = undefined;
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+            }
+            return "ARRAY[" + valueStr.join(",") + "]";
         },
     ],
     [Date, (value) => SqlValuesCreator.string(value.toISOString())],
 ]);
 
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlSelectable<any>
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-class SqlSelectable {
-    constructor(columns) {
-        // Reflect.set(this, SQL_SELECTABLE, undefined);
-        let readonlyColumns;
-        if (typeof columns[Symbol.iterator] === "function") {
-            let iterable = columns;
-            readonlyColumns = [];
-            let iter = iterable[Symbol.iterator]();
-            let i = 0;
-            let item = iter.next();
-            while (!item.done) {
-                readonlyColumns[i++] = item.value;
-                item = iter.next();
-            }
-            // readonlyColumns.length = i;
-        }
-        else {
-            let arrayLike = columns;
-            readonlyColumns = new Array(arrayLike.length);
-            // readonlyColumns.length = arrayLike.length;
-            for (let i = 0; i < arrayLike.length; i++) {
-                readonlyColumns[i] = arrayLike[i];
-            }
-        }
-        this.columns = readonlyColumns;
-    }
-}
-/**
- * 数据库表
- * @public
- */
-class DbTable extends SqlSelectable {
-    constructor(name, columns) {
-        if (!(columns instanceof Array))
-            columns = Object.keys(columns);
-        super(columns);
-        this.name = name;
-    }
-    toSelect() {
-        return this.name;
-    }
-    toString() {
-        return this.name;
-    }
-}
-/**
- * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
- * @public
- */
-class SqlQueryStatement extends SqlSelectable {
-    constructor(sql, columns) {
-        super(columns);
-        this.sql = sql;
-    }
-    toString() {
-        return this.sql;
-    }
-    toSelect() {
-        return "(" + this.toString() + ")";
-    }
-}
-
 function genOderBy(orderBy, orderNullRule) {
     let select = [];
     let v;
@@ -600,7 +675,6 @@ class TableRepeatError extends Error {
 class DbTableQuery extends DbTable {
     constructor(name, columns, statement) {
         super(name, columns);
-        this.name = name;
         this.statement = statement;
     }
     select(columns, option) {
@@ -695,4 +769,175 @@ function genWhere(where) {
     return "\nWHERE " + where;
 }
 
-export { DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, createSelect, getObjectListKeys, pgSqlTransformer };
+/**
+ * 表格列的信息
+ * @public
+ */
+class ColumnMeta {
+    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 {
+    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 {
+    constructor(is, name) {
+        this.is = is;
+        this.name = name;
+    }
+}
+CustomDbType.bigint = new CustomDbType(baseType, "bigint");
+CustomDbType.number = new CustomDbType(baseType, "number");
+CustomDbType.string = new CustomDbType(baseType, "string");
+CustomDbType.boolean = new CustomDbType(baseType, "boolean");
+
+/** @public */
+class TypeChecker {
+    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}`;
+}
+
+/**
+ * 完整数据库表数据
+ * @public
+ */
+class YourTable extends DbTableQuery {
+    constructor(name, define, sqlValue) {
+        super(name, Object.keys(define), sqlValue);
+        this.define = define;
+    }
+    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 { ColumnMeta, CustomDbType, DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, createSelect, getObjectListKeys, pgSqlTransformer };

package/dist/select/TableQuery.d.ts

@@ -4,7 +4,6 @@ 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);
     /** 选择全部列 */

package/dist/select/select.d.ts

@@ -1,5 +1,5 @@
 import { SqlSelectable, InferQueryResult, SqlQueryStatement } from "./selectable.ts";
-import type { ColumnsSelected, RowsOrder, SelectColumns, TableType } from "./type.ts";
+import type { ColumnsSelected, OrderValue, 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>>;
@@ -18,7 +18,9 @@ export interface SelectFilterOption<T extends object> {
 }
 /** @public */
 export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
-    toQuery(option?: SelectFilterOption<T>): SqlQueryStatement<T>;
+    toQuery(option?: SelectFilterOption<T & {
+        [key: string]: OrderValue;
+    }>): SqlQueryStatement<T>;
 }
 /** @public */
 export interface JoinSelect<T extends TableType> extends FinalSelect<T> {

package/dist/sql_value/sql_value.d.ts

@@ -1,3 +1,4 @@
+import { SqlSelectable } from "../select/selectable.ts";
 declare const SQL_RAW: unique symbol;
 /**
  * SQL 原始字符对象
@@ -13,18 +14,20 @@ export declare class SqlRaw<T = any> {
 /** @public */
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public */
-export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T, map: JsObjectMapSql) => string;
+export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T) => string;
 /** @public */
-export type ManualType = "bigint" | "number" | "string" | "boolean" | (new (...args: any[]) => any);
+export type ManualType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
+/** @public */
+export interface SqlValueFn {
+    /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
+    (value: any, expectType?: ManualType): string;
+}
 /**
  * SQL value 生成器
  * @public
  */
 export declare class SqlValuesCreator {
-    static create(map?: JsObjectMapSql): SqlValuesCreator & {
-        /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
-        (value: any, expectType?: ManualType): string;
-    };
+    static create(map?: JsObjectMapSql): SqlValuesCreator & SqlValueFn;
     /**
      * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
      * @example 输入 a'b'c , 返回 a''b''c.
@@ -38,8 +41,9 @@ export declare class SqlValuesCreator {
     setTransformer<T>(type: new (...args: any[]) => T, transformer?: SqlValueEncoder): void;
     private readonly map;
     /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
-    toSqlStr(value: any, expectType?: "bigint" | "number" | "string" | "boolean" | (new (...args: any[]) => any)): string;
-    protected toObjectStr(value: object): string;
+    toSqlStr(value: any, expectType?: ManualType): string;
+    /** 获取值对应的 SqlValueEncoder */
+    getObjectType(value: object): SqlValueEncoder;
     protected defaultObject(value: object): string;
     /**
      * 将对象列表转为 SQL 的 VALUES
@@ -62,6 +66,22 @@ export declare class SqlValuesCreator {
      * @example 返回示例： " 'abc', '6', 'now()' "
      */
     toValues(values: readonly any[]): string;
+    /**
+     * @public 创建 VALUES AS  语句
+     * @example
+     * ```ts
+     *  sqlValue.createValues(
+     *    "customName",
+     *    [{age:8, name:"hhh"}, {age:9, name:"row2"}],
+     *    {age:"INT", name:"TEXT"}
+     *  )
+     * // (VALUES (8:INT,'hhh':TEXT),(9,'row2')) AS customName(age, name)
+     * ```
+     */
+    createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | {
+        sqlType: string;
+        sqlDefault?: string;
+    }>): SqlSelectable<T>;
 }
 export {};
 //# sourceMappingURL=sql_value.d.ts.map

package/dist/your_table/checker.d.ts

@@ -0,0 +1,13 @@
+import { ColumnMeta } from "./infer_db_type.ts";
+/** @public */
+export declare class TypeChecker<T> {
+    private map;
+    constructor(map: Map<string, ColumnMeta<any>>);
+    check(value: {
+        [key: string]: any;
+    }): T;
+    checkList(value: any[]): T[];
+    private checkArray;
+    private checkItem;
+}
+//# sourceMappingURL=checker.d.ts.map

package/dist/your_table/infer_db_type.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 表格列的信息
+ * @public
+ */
+export declare class ColumnMeta<T> {
+    readonly type: CustomDbType<T> | (new (...args: any[]) => T);
+    /** 数据库原始数据类型 */
+    readonly sqlType: string;
+    /** 是否非空 */
+    readonly notNull: boolean;
+    /** 是否是数组类型 */
+    readonly isArray: boolean;
+    /** 数据库原始默认值 */
+    readonly sqlDefault?: string | undefined;
+    constructor(type: CustomDbType<T> | (new (...args: any[]) => T), 
+    /** 数据库原始数据类型 */
+    sqlType: string, 
+    /** 是否非空 */
+    notNull?: boolean, 
+    /** 是否是数组类型 */
+    isArray?: boolean, 
+    /** 数据库原始默认值 */
+    sqlDefault?: string | undefined);
+    /** 校验 value 的类型 */
+    checkValue(value: any): boolean;
+}
+/**
+ * 数据库类型到JS类型的映射
+ * @public
+ */
+export declare class YourTypeMap<M extends TypeMapDefined> {
+    private readonly typeMap;
+    static create<T extends TypeMapDefined>(rawTypeMap?: T): YourTypeMap<{
+        [key in keyof T]: InferTypeMapDefined<T[key]>;
+    }>;
+    constructor(typeMap?: M);
+    genColumn<T extends keyof M>(type: T, noNull: true, defaultValue?: string): ColumnMeta<M[T]>;
+    genColumn<T extends keyof M>(type: T, noNull?: boolean, defaultValue?: string): ColumnMeta<M[T] | null>;
+    genColumn<T>(type: keyof M, noNull: true, defaultValue?: string): ColumnMeta<T>;
+    genColumn<T>(type: keyof M, noNull?: boolean, defaultValue?: string): ColumnMeta<T | null>;
+    genArrColumn<T extends keyof M>(type: T, noNull: true, defaultValue?: string): ColumnMeta<M[T][]>;
+    genArrColumn<T extends keyof M>(type: T, noNull?: boolean, defaultValue?: string): ColumnMeta<M[T][] | null>;
+    genArrColumn<T>(type: keyof M, notNull: true, defaultValue?: string): ColumnMeta<T[]>;
+    genArrColumn<T>(type: keyof M, notNull?: boolean, defaultValue?: string): ColumnMeta<T[] | null>;
+}
+type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * 自定义数据类型
+ * @public
+ */
+export declare class CustomDbType<T> {
+    readonly is: (this: CustomDbType<T>, value: any) => boolean;
+    readonly name: string;
+    static readonly bigint: CustomDbType<bigint>;
+    static readonly number: CustomDbType<number>;
+    static readonly string: CustomDbType<string>;
+    static readonly boolean: CustomDbType<boolean>;
+    constructor(is: (this: CustomDbType<T>, value: any) => boolean, name: string);
+}
+type TypeMapDefined = {
+    [key: string]: Constructor | CustomDbType<any>;
+};
+type InferTypeMapDefined<T> = T extends Constructor<infer P> ? TRaw<P> : T extends CustomDbType<infer Q> ? Q : never;
+type TRaw<T> = T extends Number ? number : T extends BigInt ? bigint : T extends String ? string : T extends Boolean ? boolean : T;
+/** @public */
+export type TableDefined = {
+    [key: string]: ColumnMeta<any>;
+};
+/** @public */
+export type InferTableDefined<T extends TableDefined> = {
+    [key in keyof T]: T[key] extends ColumnMeta<infer P> ? P : unknown;
+};
+export {};
+//# sourceMappingURL=infer_db_type.d.ts.map

package/dist/your_table/mod.d.ts

@@ -0,0 +1,4 @@
+export * from "./checker.ts";
+export * from "./infer_db_type.ts";
+export * from "./table.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/your_table/table.d.ts

@@ -0,0 +1,16 @@
+import { DbTableQuery } from "../select/TableQuery.ts";
+import type { TableType } from "../select/type.ts";
+import type { SqlValuesCreator } from "../sql_value/sql_value.ts";
+import type { ColumnMeta, TableDefined } from "./infer_db_type.ts";
+import { TypeChecker } from "./checker.ts";
+/**
+ * 完整数据库表数据
+ * @public
+ */
+export declare class YourTable<T extends TableType = TableType, C extends TableType = T> extends DbTableQuery<T, C> {
+    private define;
+    constructor(name: string, define: TableDefined, sqlValue: SqlValuesCreator);
+    getColumnMeta(name: keyof T): ColumnMeta<unknown>;
+    createTypeChecker<T>(keys: readonly string[]): TypeChecker<T>;
+}
+//# sourceMappingURL=table.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
@@ -10,6 +10,7 @@
     "build": "pnpm rollup -c  build/rollup.config.js && pnpm run ci:check-api -l",
     "test": "vitest",
     "type:check": "tsc",
+    "publish-check": "deno publish --dry-run --allow-dirty",
     "ci:check-api": "api-extractor run -c api-extractor.jsonc -v"
   },
   "devDependencies": {