vona 1.0.0 → 5.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present Vona
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1 @@
-# @cabloy/set
+# vona

package/README.zh-CN.md

@@ -0,0 +1 @@
+# vona

package/dist/app/extend/context.d.ts

@@ -0,0 +1,4 @@
+import { ContextBase } from '../../types/context/contextBase.js';
+declare const context: ContextBase;
+export default context;
+//# sourceMappingURL=context.d.ts.map

package/dist/app/extend/context.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const raw_body_1 = __importDefault(require("raw-body"));
+const inflation_1 = __importDefault(require("inflation"));
+const ModuleInfo = __importStar(require("@cabloy/module-info"));
+const metaCtx_js_1 = require("../../lib/core/metaCtx.js");
+const cast_js_1 = require("../../types/utils/cast.js");
+const MODULE = Symbol.for('Context#__module');
+const META = Symbol.for('Context#__meta');
+const INNERACCESS = Symbol.for('Context#__inneraccess');
+const SUBDOMAIN = Symbol.for('Context#__subdomain');
+const CTXCALLER = Symbol.for('Context#__ctxcaller');
+const TAILCALLBACKS = Symbol.for('Context#__tailcallbacks');
+const DBLEVEL = Symbol.for('Context#__dblevel');
+const context = {
+    get module() {
+        const self = (0, cast_js_1.Cast)(this);
+        if (this[MODULE] === undefined) {
+            const url = self.req.url || '';
+            let info;
+            if (url.indexOf('/api/static/public/') === 0) {
+                info = null;
+            }
+            else {
+                info = ModuleInfo.parseInfo(ModuleInfo.parseName(url));
+            }
+            if (!info) {
+                info = ModuleInfo.parseInfo('a-base');
+            }
+            if (info) {
+                const module = self.app.meta.modules[info.relativeName];
+                // should not throw error, because the url maybe not valid
+                // if (!module) throw new Error(`module not found: ${info.relativeName}`);
+                this[MODULE] = module || null;
+            }
+            else {
+                this[MODULE] = null;
+            }
+        }
+        return this[MODULE];
+    },
+    get meta() {
+        const self = (0, cast_js_1.Cast)(this);
+        if (!this[META]) {
+            this[META] = self.bean._newBean(metaCtx_js_1.CtxMeta);
+        }
+        return this[META];
+    },
+    get innerAccess() {
+        return this[INNERACCESS];
+    },
+    set innerAccess(value) {
+        this[INNERACCESS] = value;
+    },
+    get dbLevel() {
+        return this[DBLEVEL] || 0;
+    },
+    set dbLevel(value) {
+        this[DBLEVEL] = value;
+    },
+    get subdomain() {
+        const self = (0, cast_js_1.Cast)(this);
+        return typeof this[SUBDOMAIN] === 'undefined' ? self.subdomains.join('.') : this[SUBDOMAIN];
+    },
+    set subdomain(value) {
+        this[SUBDOMAIN] = value;
+    },
+    get ctxCaller() {
+        return this[CTXCALLER];
+    },
+    set ctxCaller(value) {
+        // ctxCaller
+        this[CTXCALLER] = value;
+        // innerAccess
+        this.innerAccess = true;
+        // transaction
+        (0, cast_js_1.Cast)(this).dbMeta = value.dbMeta;
+        // dbLevel
+        this.dbLevel = value.dbLevel;
+    },
+    get cache() {
+        const self = (0, cast_js_1.Cast)(this);
+        return self.bean._getBean('cache');
+    },
+    tail(cb) {
+        if (!(0, cast_js_1.Cast)(this).dbMeta.master) {
+            this.ctxCaller.tail(cb);
+        }
+        else {
+            this.tailCallbacks.push(cb);
+        }
+    },
+    async tailDone() {
+        while (true) {
+            const cb = this.tailCallbacks.shift();
+            if (!cb)
+                break;
+            await cb();
+            // try {
+            //   await cb();
+            // } catch (err) {
+            //   this.app.logger.error(err);
+            // }
+        }
+    },
+    get tailCallbacks() {
+        if (!this[TAILCALLBACKS]) {
+            this[TAILCALLBACKS] = [];
+        }
+        return this[TAILCALLBACKS];
+    },
+    successMore(list, index, size) {
+        const self = (0, cast_js_1.Cast)(this);
+        self.success({
+            list,
+            index: index + list.length,
+            finished: size === -1 || size === 0 || list.length < size,
+        });
+    },
+    async getPayload(options) {
+        const self = (0, cast_js_1.Cast)(this);
+        return await (0, raw_body_1.default)((0, inflation_1.default)(self.req), options);
+    },
+};
+exports.default = context;
+//# sourceMappingURL=context.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import '@cabloy/set';
+import '@cabloy/json5';
+import 'regenerator-runtime';
+export * from './types/index.js';
+export * from './lib/bean/index.js';
+export * from './lib/core/index.js';
+export * from './lib/decorator/index.js';
+export * from './lib/module/index.js';
+export * from './lib/framework/framework.js';
+export * from './lib/utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@cabloy/set");
+require("@cabloy/json5");
+require("regenerator-runtime");
+const module_alias_1 = __importDefault(require("module-alias"));
+const cluster_reload_1 = __importDefault(require("@cabloy/cluster-reload"));
+const master_js_1 = __importDefault(require("egg-cluster/lib/master.js"));
+module_alias_1.default.addAlias('koa-static-cache', '@cabloy/koa-static-cache');
+master_js_1.default.prototype.onReload = cluster_reload_1.default;
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./lib/bean/index.js"), exports);
+__exportStar(require("./lib/core/index.js"), exports);
+__exportStar(require("./lib/decorator/index.js"), exports);
+__exportStar(require("./lib/module/index.js"), exports);
+__exportStar(require("./lib/framework/framework.js"), exports);
+__exportStar(require("./lib/utils/index.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/base/dbTransaction.d.ts

@@ -0,0 +1,12 @@
+import { CabloyContext } from '../../types/index.js';
+export default class DbTransaction {
+    _ctx: CabloyContext;
+    _transactionCounter: number;
+    _connection: any;
+    constructor(ctx: any);
+    get inTransaction(): boolean;
+    get connection(): any;
+    set connection(value: any);
+    begin(fn: any): Promise<any>;
+}
+//# sourceMappingURL=dbTransaction.d.ts.map

package/dist/lib/base/dbTransaction.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DbTransaction {
+    constructor(ctx) {
+        this._ctx = ctx;
+        this._transactionCounter = 0;
+        this._connection = null;
+    }
+    get inTransaction() {
+        return this._transactionCounter > 0;
+    }
+    get connection() {
+        return this._connection;
+    }
+    set connection(value) {
+        this._connection = value;
+    }
+    async begin(fn) {
+        let res;
+        const db = this._ctx.meta.util.getDbOriginal();
+        try {
+            if (++this._transactionCounter === 1) {
+                this._connection = await db.beginTransaction();
+            }
+        }
+        catch (err) {
+            this._transactionCounter--;
+            throw err;
+        }
+        try {
+            res = await fn();
+        }
+        catch (err) {
+            if (--this._transactionCounter === 0) {
+                await this._connection.rollback();
+                this._connection = null;
+            }
+            throw err;
+        }
+        try {
+            if (--this._transactionCounter === 0) {
+                await this._connection.commit();
+                this._connection = null;
+            }
+        }
+        catch (err) {
+            await this._connection.rollback();
+            this._connection = null;
+            throw err;
+        }
+        return res;
+    }
+}
+exports.default = DbTransaction;
+//# sourceMappingURL=dbTransaction.js.map

package/dist/lib/base/error.d.ts

@@ -0,0 +1,18 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class ErrorClass extends BeanSimple {
+    ebErrors: any;
+    constructor(ebErrors: any);
+    success(module: any, data: any, code: any, ...args: any[]): void;
+    fail(module: any, code: any, ...args: any[]): void;
+    throw(module: any, code: any, ...args: any[]): void;
+    parseFail(module: any, code: any, ...args: any[]): any;
+    parseSuccess(module: any, code: any, ...args: any[]): {
+        code: any;
+        message: null;
+    };
+    parseCode(module: any, codeDefault: any, code: any, ...args: any[]): {
+        code: any;
+        message: null;
+    };
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/lib/base/error.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorClass = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class ErrorClass extends beanSimple_js_1.BeanSimple {
+    constructor(ebErrors) {
+        super();
+        this.ebErrors = ebErrors;
+    }
+    // data,code/message,args
+    success(module, data, code, ...args) {
+        const body = this.parseSuccess(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: 0, message: body.message, data };
+    }
+    // code/message,args
+    fail(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: __combineErrorCode(module, body.code), message: body.message }; // body maybe Error
+    }
+    // code/message,args
+    throw(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        const err = new Error();
+        err.code = __combineErrorCode(module, body.code);
+        err.message = body.message;
+        if (body.code < 500)
+            err.status = body.code;
+        throw err;
+    }
+    // code/message,args
+    parseFail(module, code, ...args) {
+        if (typeof code === 'object')
+            return code;
+        return this.parseCode(module, 1, code, ...args);
+    }
+    // code/message,args
+    parseSuccess(module, code, ...args) {
+        return this.parseCode(module, 0, code, ...args);
+    }
+    // parseCode
+    parseCode(module, codeDefault, code, ...args) {
+        const ebError = this.ebErrors[module];
+        let message = null;
+        if (code === undefined || code === null || code === '') {
+            code = codeDefault;
+        }
+        else if (typeof code === 'string') {
+            message = this.ctx.text(code, ...args);
+            code = codeDefault;
+        }
+        else {
+            message = this.ctx.text(ebError[code], ...args);
+        }
+        if (!message) {
+            message = this.ctx.text(ebError[codeDefault]);
+        }
+        return { code, message };
+    }
+}
+exports.ErrorClass = ErrorClass;
+function __combineErrorCode(module, code) {
+    if (code <= 1000)
+        return code;
+    return module ? `${module}:${code}` : code;
+}
+//# sourceMappingURL=error.js.map

package/dist/lib/base/model.d.ts

@@ -0,0 +1,22 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class Model extends BeanSimple {
+    table: string;
+    options: any;
+    constructor({ table, options }: {
+        table: any;
+        options?: {} | undefined;
+    });
+    get disableDeleted(): any;
+    get disableInstance(): any;
+    columns(tableName?: string): Promise<any>;
+    columnsClear(tableName: any): any;
+    columnsClearAll(): boolean;
+    prepareData(item: any): Promise<{}>;
+    default(data: any): Promise<any>;
+    _coerceTypeOfDefault(column: any): any;
+    create(data: any, ...args: any[]): Promise<any>;
+    write(data: any, ...args: any[]): Promise<any>;
+    _rowCheck(row: any): void;
+    _insertRowsCheck(rows: any): void;
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/lib/base/model.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const is_type_of_1 = __importDefault(require("is-type-of"));
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+let __columns = {};
+class Model extends beanSimple_js_1.BeanSimple {
+    constructor({ table, options = {} }) {
+        super();
+        this.table = table;
+        this.options = options;
+    }
+    get disableDeleted() {
+        return this.options.disableDeleted === undefined
+            ? this.app.config.model.disableDeleted
+            : this.options.disableDeleted;
+    }
+    get disableInstance() {
+        return this.options.disableInstance === undefined
+            ? this.app.config.model.disableInstance
+            : this.options.disableInstance;
+    }
+    async columns(tableName) {
+        tableName = tableName || this.table;
+        let columns = __columns[tableName];
+        if (!columns) {
+            const list = await this.ctx.db.query(`show columns from ${this.ctx.db.format('??', tableName)}`);
+            columns = __columns[tableName] = {};
+            for (const item of list) {
+                columns[item.Field] = item;
+            }
+        }
+        return columns;
+    }
+    columnsClear(tableName) {
+        tableName = tableName || this.table;
+        const exists = __columns[tableName];
+        delete __columns[tableName];
+        return exists;
+    }
+    columnsClearAll() {
+        const exists = Object.keys(__columns).length > 0;
+        __columns = {};
+        return exists;
+    }
+    async prepareData(item) {
+        // columns
+        const columns = await this.columns();
+        // data
+        const data = {};
+        for (const columnName in columns) {
+            if (item[columnName] !== undefined) {
+                data[columnName] = item[columnName];
+            }
+        }
+        return data;
+    }
+    async default(data) {
+        data = data || {};
+        // columns
+        const columns = await this.columns();
+        for (const columnName in columns) {
+            const column = columns[columnName];
+            data[columnName] = this._coerceTypeOfDefault(column);
+        }
+        return data;
+    }
+    _coerceTypeOfDefault(column) {
+        // type
+        let type = column.Type;
+        const pos = type.indexOf('(');
+        if (pos > -1)
+            type = type.substring(0, pos);
+        // default value
+        const value = column.Default;
+        // coerce
+        if (value === null)
+            return value;
+        if (['timestamp'].includes(type) && value === 'CURRENT_TIMESTAMP')
+            return new Date();
+        if (['bit', 'bool'].includes(type))
+            return Boolean(value);
+        if (['float', 'double'].includes(type))
+            return Number(value);
+        if (['tinyint', 'smallint', 'mediumint', 'int', 'bigint'].includes(type))
+            return Number(value);
+        // others
+        return value;
+    }
+    async create(data, ...args) {
+        const data2 = await this.prepareData(data);
+        const res = await this.insert(data2, ...args);
+        return res.insertId;
+    }
+    async write(data, ...args) {
+        const data2 = await this.prepareData(data);
+        return await this.update(data2, ...args);
+    }
+    _rowCheck(row) {
+        if ((!this.table || !this.disableInstance) && row.iid === undefined) {
+            row.iid = this.ctx.instance.id;
+        }
+        if (this.table && !this.disableDeleted && row.deleted === undefined) {
+            row.deleted = 0;
+        }
+    }
+    _insertRowsCheck(rows) {
+        if (!Array.isArray(rows))
+            return this._rowCheck(rows);
+        for (const row of rows) {
+            this._rowCheck(row);
+        }
+    }
+}
+exports.Model = Model;
+[
+    'literals', //
+    'escape',
+    'escapeId',
+    'format',
+    '_formatValue',
+    '_formatWhere',
+    '_where',
+    '_orders',
+    'raw',
+    'query',
+    'queryOne',
+    '_query',
+    '_selectColumns',
+    '_limit',
+].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            if (is_type_of_1.default.function(this.ctx.db[method])) {
+                return function (...args) {
+                    return this.ctx.db[method](...args);
+                };
+            }
+            // property
+            return this.ctx.db[method];
+        },
+    });
+});
+['insert'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                if (args.length === 0) {
+                    args.push({});
+                }
+                if (this.table) {
+                    args.unshift(this.table);
+                }
+                this._insertRowsCheck(args[1]);
+                return this.ctx.db[method](...args);
+            };
+        },
+    });
+});
+['update'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                const _args = [];
+                if (this.table)
+                    _args.push(this.table);
+                for (const arg of args)
+                    _args.push(arg);
+                if (_args[2] && _args[2].where) {
+                    this._rowCheck(_args[2].where);
+                }
+                return this.ctx.db[method](..._args);
+            };
+        },
+    });
+});
+['delete'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                const _args = [];
+                if (this.table)
+                    _args.push(this.table);
+                for (const arg of args)
+                    _args.push(arg);
+                _args[1] = _args[1] || {};
+                this._rowCheck(_args[1]);
+                if (this.table && !this.disableDeleted) {
+                    const sql = this.ctx.db.format('UPDATE ?? SET deleted=1 ', [_args[0]]) + this.ctx.db._where(_args[1]);
+                    return this.ctx.db.query(sql);
+                }
+                return this.ctx.db[method](..._args);
+            };
+        },
+    });
+});
+['count'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                const _args = [];
+                if (this.table)
+                    _args.push(this.table);
+                for (const arg of args)
+                    _args.push(arg);
+                _args[1] = _args[1] || {};
+                this._rowCheck(_args[1]);
+                return this.ctx.db[method](..._args);
+            };
+        },
+    });
+});
+['get'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                // console.log(this.constructor.name, arguments);
+                const _args = [];
+                if (this.table)
+                    _args.push(this.table);
+                for (const arg of args)
+                    _args.push(arg);
+                _args[1] = _args[1] || {};
+                // if (_args[1].id) {
+                //   return this.ctx.db[method].apply(this.ctx.db, _args);
+                // }
+                this._rowCheck(_args[1]);
+                return this.ctx.db[method](..._args);
+            };
+        },
+    });
+});
+['select'].forEach(method => {
+    Object.defineProperty(Model.prototype, method, {
+        get() {
+            return function (...args) {
+                const _args = [];
+                if (this.table)
+                    _args.push(this.table);
+                for (const arg of args)
+                    _args.push(arg);
+                _args[1] = _args[1] || {};
+                _args[1].where = _args[1].where || {};
+                this._rowCheck(_args[1].where);
+                return this.ctx.db[method](..._args);
+            };
+        },
+    });
+});
+//# sourceMappingURL=model.js.map

package/dist/lib/bean/_beanLocal_.d.ts

@@ -0,0 +1,6 @@
+import { BeanModuleScopeBase } from './beanModuleScopeBase.js';
+export declare class BeanLocal extends BeanModuleScopeBase {
+    protected __get__(prop: any): unknown;
+    module(moduleScope: string): typeof this;
+}
+//# sourceMappingURL=_beanLocal_.d.ts.map