@wzyjs/types 0.0.28

package/dist/cjs/rd/database/Collection.js

@@ -0,0 +1,202 @@
+'use strict';
+
+var lodash = require('lodash');
+var utils = require('./utils.js');
+var types = require('./types.js');
+
+class Collection {
+    db;
+    collection;
+    constructor(db, name) {
+        this.db = db;
+        this.collection = db.collection(name);
+    }
+    joinConditions(conditions) {
+        let record = this.collection;
+        if (!conditions) {
+            return record;
+        }
+        // 如果是根据 _id 查询
+        if ('_id' in conditions) {
+            record = record.doc(conditions._id);
+            // 如果是根据 条件 查询
+        }
+        else {
+            const { page, order, where, options } = conditions;
+            if (options) {
+                record = record.options(options);
+            }
+            if (where) {
+                record = record.where(where);
+            }
+            if (order) {
+                record = record.orderBy(order.field, order.type || 'desc');
+            }
+            if (page?.current && page?.size) {
+                record = record.skip((page.current - 1) * page.size);
+            }
+            if (page?.size) {
+                record = record.limit(page.size);
+            }
+        }
+        if (Array.isArray(conditions.field)) {
+            record = record.field(conditions.field.reduce((o, i) => ({ ...o, [i]: true }), {}));
+        }
+        else if (conditions.field) {
+            record = record.field(conditions.field);
+        }
+        return record;
+    }
+    request(params) {
+        switch (params.method) {
+            case types.Method.Add:
+                return this.joinConditions().add(params.data);
+            case types.Method.Find:
+            case types.Method.FindList:
+                return this.joinConditions(params.conditions).get();
+            case types.Method.Delete:
+                return this.joinConditions(params.conditions).remove();
+            case types.Method.Update:
+                if (params.isSet && '_id' in params.conditions) {
+                    return this.joinConditions(params.conditions).set(params.data);
+                }
+                return this.joinConditions(params.conditions).update(params.data);
+            case types.Method.Count:
+                return this.joinConditions(params.conditions).count();
+            default:
+                throw new Error('method is not exist');
+        }
+    }
+    // 处理出参
+    async handleRes(params, res) {
+        if (res) {
+            delete res.requestId;
+        }
+        let data = res;
+        switch (params.method) {
+            case types.Method.Add:
+                const addRes = res;
+                if (addRes.id && params.isReturn) {
+                    data = await this.find({ _id: addRes.id, field: params.conditions?.field });
+                }
+                break;
+            case types.Method.Update:
+                const updateRes = res;
+                if (updateRes.updated && params.isReturn && '_id' in params.conditions) {
+                    data = await this.find({ _id: params.conditions._id, field: params.conditions?.field });
+                }
+                break;
+            case types.Method.Find:
+                const getRes = res;
+                data = getRes?.data[0] || null;
+                break;
+            case types.Method.FindList:
+                const getListRes = res;
+                const countRes = await this.request({
+                    method: types.Method.Count,
+                    conditions: params.conditions,
+                });
+                data = {
+                    list: getListRes.data,
+                    total: countRes.total,
+                };
+                break;
+        }
+        return data;
+    }
+    // 处理数据
+    async handleData(params) {
+        switch (params.method) {
+            case types.Method.Add:
+                params.data = utils.appendTime(params.data, 'create');
+                params.data = utils.appendTime(params.data, 'update');
+                break;
+            case types.Method.Update:
+                if ('_id' in params.data) {
+                    delete params.data._id;
+                }
+                break;
+        }
+        return params;
+    }
+    // 处理条件
+    handleConditions(params) {
+        if (params.method !== types.Method.Add) {
+            params.conditions = lodash.merge(lodash.cloneDeep(utils.defaultConditions), params.conditions);
+        }
+        // 处理 where 条件
+        if (params.conditions && 'where' in params.conditions) {
+            const { command: _ } = this.db;
+            for (const key in params.conditions.where) {
+                const whereValue = params.conditions.where[key];
+                if (lodash.isObject(whereValue)) {
+                    const { type, value } = whereValue;
+                    switch (type) {
+                        case types.Command.In:
+                            params.conditions.where[key] = _.in(value);
+                            break;
+                        case types.Command.Nin:
+                            params.conditions.where[key] = _.nin(value);
+                            break;
+                        case types.Command.Gt:
+                            params.conditions.where[key] = _.gt(value);
+                            break;
+                        case types.Command.Gte:
+                            params.conditions.where[key] = _.gte(value);
+                            break;
+                        case types.Command.Lt:
+                            params.conditions.where[key] = _.lt(value);
+                            break;
+                        case types.Command.Lte:
+                            params.conditions.where[key] = _.lte(value);
+                            break;
+                        case types.Command.Eq:
+                            params.conditions.where[key] = _.eq(value);
+                            break;
+                        case types.Command.Neq:
+                            params.conditions.where[key] = _.neq(value);
+                            break;
+                        case types.Command.Gtlt:
+                            params.conditions.where[key] = _.and(_.gt(value[0]), _.lt(value[1]));
+                            break;
+                        default:
+                            const check = type;
+                            console.error(666, '处理 where 条件 出现未定义的情况', check);
+                            break;
+                    }
+                }
+            }
+        }
+        return params;
+    }
+    async exec(params) {
+        params = await this.handleData(params);
+        params = await this.handleConditions(params);
+        const res = await this.request(params);
+        return this.handleRes(params, res);
+    }
+    add(data, isReturn, conditions) {
+        return this.exec({ method: types.Method.Add, conditions, data, isReturn });
+    }
+    // 删
+    delete(conditions) {
+        return this.exec({ method: types.Method.Delete, conditions });
+    }
+    update(conditions, data, isReturn, isSet) {
+        return this.exec({ method: types.Method.Update, conditions, data, isReturn, isSet });
+    }
+    // 查
+    find(conditions) {
+        return this.exec({ method: types.Method.Find, conditions });
+    }
+    // 查列表
+    findList(conditions) {
+        return this.exec({ method: types.Method.FindList, conditions });
+    }
+    // 查
+    count(conditions) {
+        return this.exec({ method: types.Method.Count, conditions });
+    }
+}
+
+exports.Collection = Collection;

package/dist/cjs/rd/database/Database.d.ts

@@ -0,0 +1,10 @@
+import tcb, { IKeyValue } from '@cloudbase/node-sdk';
+import { Config } from './types';
+import { Collection } from './Collection';
+export declare class Database {
+    private readonly db;
+    private readonly instance;
+    constructor(config: Config);
+    collection<D extends IKeyValue>(name: string): Collection<D>;
+    createCollection(name: string): tcb.IBaseRes;
+}

package/dist/cjs/rd/database/Database.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var nodeSdk = require('@cloudbase/node-sdk');
+var Collection = require('./Collection.js');
+
+class Database {
+    db;
+    instance = {};
+    constructor(config) {
+        this.db = nodeSdk.init(config).database();
+    }
+    // 封装了较多功能的 collection
+    collection(name) {
+        if (!this.instance[name]) {
+            this.instance[name] = new Collection.Collection(this.db, name);
+        }
+        return this.instance[name];
+    }
+    // 创建 collection
+    createCollection(name) {
+        return this.db.createCollection(name);
+    }
+}
+
+exports.Database = Database;

package/dist/cjs/rd/database/index.d.ts

@@ -0,0 +1,2 @@
+export { Database } from './Database';
+export { Conditions, IdConditions, WhereConditions, Record } from './types';

package/dist/cjs/rd/database/types.d.ts

@@ -0,0 +1,151 @@
+import { Database, ICountRes } from '@cloudbase/node-sdk';
+export interface Config {
+    env: string;
+    secretId: string;
+    secretKey: string;
+}
+export type IdConditions = {
+    _id: string;
+    field?: string[] | {
+        [key: string]: false;
+    };
+    options?: {
+        timeout: number;
+        multiple?: false;
+    };
+};
+export declare enum Command {
+    Eq = "eq",
+    Neq = "neq",
+    Lt = "lt",
+    Lte = "lte",
+    Gt = "gt",
+    Gte = "gte",
+    In = "in",
+    Nin = "nin",
+    Gtlt = "gtlt"
+}
+export type CommandWhere = {
+    type: Command.Eq;
+    value: any;
+} | {
+    type: Command.Neq;
+    value: any;
+} | {
+    type: Command.Gt;
+    value: number;
+} | {
+    type: Command.Gte;
+    value: number;
+} | {
+    type: Command.Lt;
+    value: number;
+} | {
+    type: Command.Lte;
+    value: number;
+} | {
+    type: Command.Gtlt;
+    value: number[];
+} | {
+    type: Command.In;
+    value: any[];
+} | {
+    type: Command.Nin;
+    value: any[];
+};
+export type WhereConditions = {
+    where?: {
+        [key: string]: any | CommandWhere;
+    };
+    field?: string[] | {
+        [key: string]: false;
+    };
+    page?: {
+        size?: number;
+        current?: number;
+    };
+    order?: {
+        field: string;
+        type?: 'asc' | 'desc';
+    };
+    options?: {
+        timeout?: number;
+        multiple?: boolean;
+    };
+};
+export type Conditions = IdConditions | WhereConditions;
+export declare enum Method {
+    Add = "add",
+    Find = "find",
+    FindList = "findList",
+    Delete = "delete",
+    Update = "update",
+    Count = "count"
+}
+export declare namespace Add {
+    type Params<D> = {
+        method: Method.Add;
+        data: D;
+        conditions?: Pick<IdConditions, 'field'>;
+        isReturn?: true;
+    };
+    type Res = {
+        id: string;
+    };
+}
+export declare namespace Find {
+    type Params = {
+        method: Method.Find;
+        conditions?: Conditions;
+    };
+    type Res<D> = Record<D> | undefined;
+}
+export declare namespace FindList {
+    type Params = {
+        method: Method.FindList;
+        conditions?: WhereConditions;
+    };
+    type Res<D> = {
+        list?: Record<D>[];
+        total?: number;
+    };
+}
+export declare namespace Delete {
+    type Params = {
+        method: Method.Delete;
+        conditions: Conditions;
+    };
+    type Res = {
+        deleted: number | string;
+    };
+}
+export declare namespace Update {
+    type Params<D> = {
+        method: Method.Update;
+        conditions: Conditions;
+        data: Partial<Record<D>>;
+        isReturn?: true;
+        isSet?: true;
+    };
+    type Res<D> = {
+        updated?: number;
+        doc?: D;
+    };
+}
+export declare namespace Count {
+    type Params = {
+        method: Method.Count;
+        conditions?: WhereConditions;
+    };
+    type Res = {
+        total?: number;
+    };
+}
+export type MethodParams<D> = Add.Params<D> | Find.Params | FindList.Params | Delete.Params | Update.Params<D> | Count.Params;
+export type MethodRes<D> = Add.Res | Find.Res<D> | FindList.Res<D> | Delete.Res | Update.Res<D> | Count.Res;
+export type IRes = Database.IAddRes | Database.IGetRes | Database.IDeleteResult | Database.IUpdateResult | ICountRes;
+export type Record<D> = D & {
+    _id: string;
+    createAt: number;
+    updateAt: number;
+};

package/dist/cjs/rd/database/types.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// 查询数据库的条件 - 比较的特殊条件
+exports.Command = void 0;
+(function (Command) {
+    Command["Eq"] = "eq";
+    Command["Neq"] = "neq";
+    Command["Lt"] = "lt";
+    Command["Lte"] = "lte";
+    Command["Gt"] = "gt";
+    Command["Gte"] = "gte";
+    Command["In"] = "in";
+    Command["Nin"] = "nin";
+    Command["Gtlt"] = "gtlt";
+})(exports.Command || (exports.Command = {}));
+// 查询的方法
+exports.Method = void 0;
+(function (Method) {
+    Method["Add"] = "add";
+    Method["Find"] = "find";
+    Method["FindList"] = "findList";
+    Method["Delete"] = "delete";
+    Method["Update"] = "update";
+    Method["Count"] = "count";
+})(exports.Method || (exports.Method = {}));

package/dist/cjs/rd/database/utils.d.ts

@@ -0,0 +1,3 @@
+import { Conditions } from './types';
+export declare const appendTime: <D>(data: D, type: 'create' | 'update') => D;
+export declare const defaultConditions: Conditions;

package/dist/cjs/rd/database/utils.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// 给记录添加时间
+const appendTime = (data, type) => {
+    if (!data) {
+        return {};
+    }
+    return {
+        ...data,
+        [type + 'At']: Date.now(),
+    };
+};
+// 默认条件
+const defaultConditions = {
+    order: {
+        field: 'createAt',
+        type: 'desc',
+    },
+    options: {
+        timeout: 10000,
+        multiple: true,
+    },
+    page: {
+        current: 1,
+        size: 10,
+    },
+};
+
+exports.appendTime = appendTime;
+exports.defaultConditions = defaultConditions;

package/dist/cjs/rd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './database';
+export * from './jsonFile';
+export * from './mail';

package/dist/cjs/rd/jsonFile/index.d.ts

@@ -0,0 +1,6 @@
+export declare class JsonFile {
+    filePath: string;
+    constructor(filePath: string);
+    get(key: string): Promise<unknown>;
+    set(key: string, value: any): void;
+}

package/dist/cjs/rd/jsonFile/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+// 实现一个文件系统读写数据库
+class JsonFile {
+    filePath;
+    constructor(filePath) {
+        this.filePath = path.resolve(__dirname, filePath);
+    }
+    get(key) {
+        return new Promise((resolve) => {
+            fs.readFile(this.filePath, (err, data) => {
+                const json = data ? JSON.parse(data) : {};
+                resolve(json[key]);
+            });
+        });
+    }
+    set(key, value) {
+        fs.readFile(this.filePath, { encoding: 'utf-8' }, (err, data) => {
+            const json = data ? JSON.parse(data || '{}') : {};
+            json[key] = value;
+            fs.writeFile(this.filePath, JSON.stringify(json), () => {
+            });
+        });
+    }
+}
+
+exports.JsonFile = JsonFile;

package/dist/cjs/rd/mail/index.d.ts

@@ -0,0 +1 @@
+export declare const sendMail: (toEmail: string, title: string, content?: string) => Promise<string>;

package/dist/cjs/rd/mail/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var nodemailer = require('nodemailer');
+
+const fromEmail = '15835196981@163.com';
+const fromPass = 'KPTVCFBMRXJVTCGW';
+const transporter = nodemailer.createTransport({
+    host: 'smtp.163.com',
+    port: 465,
+    secure: true,
+    auth: {
+        user: fromEmail,
+        pass: fromPass
+    }
+});
+const sendMail = async (toEmail, title, content) => {
+    try {
+        await transporter.sendMail({
+            from: fromEmail,
+            to: toEmail,
+            subject: title,
+            text: content // 邮件正文
+        });
+        return title + ' 邮件通知成功';
+    }
+    catch (error) {
+        return title + '邮件通知失败' + JSON.stringify(error);
+    }
+};
+
+exports.sendMail = sendMail;

package/dist/cjs/rd/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './logger';

package/dist/cjs/rd/middlewares/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: (next: any) => Promise<void>;

package/dist/esm/common/index.d.ts

@@ -0,0 +1,6 @@
+import { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError, find, groupBy, noop } from 'lodash';
+export { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError, find, groupBy, noop, };
+export * as consola from 'consola';
+export * from './tools';
+export * from './types';
+export { default as _ } from 'lodash';

package/dist/esm/common/tools/index.d.ts

@@ -0,0 +1,4 @@
+export * from './string';
+export * from './object';
+export * from './other';
+export * from './number';

package/dist/esm/common/tools/number.d.ts

@@ -0,0 +1,3 @@
+export declare const getRandomNum: (min: number, max: number) => number;
+export declare const limitDecimals: (v: string, num: number | undefined, isForce: boolean) => string;
+export declare const getFileSize: (size: number) => string;

package/dist/esm/common/tools/number.js

@@ -0,0 +1,30 @@
+// 取指定范围内的随机数
+const getRandomNum = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+// 指定小数点的位数
+const limitDecimals = (v, num = 2, isForce) => {
+    let value = parseFloat(v);
+    if (isNaN(value)) {
+        if (isForce) {
+            value = 0;
+        }
+        else {
+            return '';
+        }
+    }
+    return value.toFixed(num).toString();
+};
+// 转换成更易读的尺寸单位
+const getFileSize = (size) => {
+    let d = 'G';
+    let s = size / 1024 / 1024 / 1024;
+    if (s < 1) {
+        d = 'M';
+        s *= 1024;
+    }
+    // @ts-ignore
+    return `${(s.toFixed(1) / 1).toString()}${d}`;
+};
+
+export { getFileSize, getRandomNum, limitDecimals };

package/dist/esm/common/tools/object.d.ts

@@ -0,0 +1,10 @@
+export declare const findItem: <I>(list: I[], attr: keyof I, value?: I[keyof I] | undefined) => I | undefined;
+export declare const filterParams: (params: {
+    [key: string]: any;
+}) => {};
+export declare const watch: {
+    observe(obj: {
+        [key: string]: any;
+    }, key: string, watchFun: (value: any, val: any) => undefined): void;
+    setWatcher(data?: {}, watch?: {}): void;
+};

package/dist/esm/common/tools/object.js

@@ -0,0 +1,39 @@
+// 判断是否有包含指定属性的对象，第三个参数可以指定具体的值
+const findItem = (list, attr, value) => {
+    return list.find((item) => value === undefined ? item[attr] : item[attr] === value);
+};
+// 过滤对象中为undefined的属性
+const filterParams = (params) => {
+    return Object.entries(params || {}).reduce((obj, [key, value]) => {
+        if (value !== undefined) {
+            obj[key] = value;
+        }
+        return obj;
+    }, {});
+};
+// 监听属性
+const watch = {
+    observe(obj, key, watchFun) {
+        // 给该属性设默认值
+        const val = obj[key];
+        Object.defineProperty(obj, key, {
+            configurable: true,
+            enumerable: true,
+            set(value) {
+                obj[key] = value;
+                // 赋值(set)时，调用对应函数
+                watchFun(value, val);
+            },
+            get() {
+                return val;
+            },
+        });
+    },
+    setWatcher(data = {}, watch = {}) {
+        Object.keys(watch).forEach(v => {
+            this.observe(data, v, watch[v]); // 监听data内的v属性，传入watch内对应函数以调用
+        });
+    },
+};
+
+export { filterParams, findItem, watch };

package/dist/esm/common/tools/other.d.ts

@@ -0,0 +1,26 @@
+import { KeyValue, OrderParams, Pagination, SortParams } from '../types';
+export declare const handleParams: (params?: Pagination & KeyValue, sort?: SortParams) => {
+    page: {
+        size?: number | undefined;
+        current?: number | undefined;
+    };
+    where: KeyValue<string, string | number | boolean | RegExp>;
+    order?: OrderParams<string> | undefined;
+};
+export declare const handleRes2List: <D>(reqPromise: any) => Promise<{
+    label: string;
+    value: string;
+}[]>;
+export declare const executePromise: (promise: Promise<any>) => Promise<{
+    result: any;
+    time: number;
+}>;
+export declare const locationFn: {
+    url2Params: (url?: string) => {};
+    params2Url: (params: {
+        [key: string]: any;
+    }) => string;
+    setUrlParams: (key: string, value: any, keepName: string) => void;
+    urlGetPath: (url?: string) => string;
+};
+export declare const delay: (time?: number) => Promise<unknown>;