@midwayjs/casbin 3.5.3

package/README.md

@@ -0,0 +1,12 @@
+# midwayjs casbin module
+
+[![Package Quality](http://npm.packagequality.com/shield/midway-core.svg)](http://packagequality.com/#?package=midway-core)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/adapter.d.ts

@@ -0,0 +1,30 @@
+import { FilteredAdapter, Model } from 'casbin';
+interface Line {
+    ptype: string;
+    v0: string;
+    v1: string;
+    v2: string;
+    v3: string;
+    v4: string;
+    v5: string;
+}
+export declare abstract class BaseAdapter<AdapterLine extends Line> implements FilteredAdapter {
+    private filtered;
+    private policies;
+    isFiltered(): boolean;
+    loadPolicy(model: Model): Promise<void>;
+    savePolicy(model: Model): Promise<boolean>;
+    addPolicy(sec: string, ptype: string, rule: string[]): Promise<void>;
+    removePolicy(sec: string, ptype: string, rule: string[]): Promise<void>;
+    loadFilteredPolicy(model: Model, filter: any): Promise<void>;
+    removeFilteredPolicy(sec: string, ptype: string, fieldIndex: number, ...fieldValues: string[]): Promise<void>;
+    private loadPolicyLine;
+    private savePolicyLine;
+    protected abstract getAdapterLine(): new () => AdapterLine;
+    protected abstract loadPolicyByAdapter(): Promise<AdapterLine[]>;
+    protected abstract loadPolicyWithFilterByAdapter(filter: any): Promise<AdapterLine[]>;
+    protected abstract savePolicyByAdapter(policies: AdapterLine[]): Promise<void>;
+    protected abstract removePolicyByAdapter(removePolicy: AdapterLine, newestPolicies?: AdapterLine[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = void 0;
+const casbin_1 = require("casbin");
+class BaseAdapter {
+    constructor() {
+        this.filtered = false;
+    }
+    isFiltered() {
+        return this.filtered;
+    }
+    async loadPolicy(model) {
+        const policies = await this.loadPolicyByAdapter();
+        this.policies = policies;
+        for (const line of policies) {
+            this.loadPolicyLine(line, model);
+        }
+    }
+    async savePolicy(model) {
+        const policyRuleAST = model.model.get('p');
+        const groupingPolicyAST = model.model.get('g');
+        const policies = [];
+        for (const astMap of [policyRuleAST, groupingPolicyAST]) {
+            for (const [ptype, ast] of astMap) {
+                for (const rule of ast.policy) {
+                    const line = this.savePolicyLine(ptype, rule);
+                    policies.push(line);
+                }
+            }
+        }
+        await this.savePolicyByAdapter(policies);
+        return true;
+    }
+    async addPolicy(sec, ptype, rule) {
+        const line = this.savePolicyLine(ptype, rule);
+        this.policies.push(line);
+        await this.savePolicyByAdapter(this.policies);
+    }
+    async removePolicy(sec, ptype, rule) {
+        const filteredPolicies = this.policies.filter(policy => {
+            let flag = true;
+            flag && (flag = ptype === policy.ptype);
+            if (rule.length > 0) {
+                flag && (flag = rule[0] === policy.v0);
+            }
+            if (rule.length > 1) {
+                flag && (flag = rule[1] === policy.v1);
+            }
+            if (rule.length > 2) {
+                flag && (flag = rule[2] === policy.v2);
+            }
+            if (rule.length > 3) {
+                flag && (flag = rule[3] === policy.v3);
+            }
+            if (rule.length > 4) {
+                flag && (flag = rule[4] === policy.v4);
+            }
+            if (rule.length > 5) {
+                flag && (flag = rule[5] === policy.v5);
+            }
+            return !flag;
+        });
+        this.policies = filteredPolicies;
+        const line = this.savePolicyLine(ptype, rule);
+        await this.removePolicyByAdapter(line, filteredPolicies);
+    }
+    async loadFilteredPolicy(model, filter) {
+        const filteredPolicies = await this.loadPolicyWithFilterByAdapter(filter);
+        this.policies = filteredPolicies;
+        filteredPolicies.forEach((policy) => {
+            this.loadPolicyLine(policy, model);
+        });
+        this.filtered = true;
+    }
+    async removeFilteredPolicy(sec, ptype, fieldIndex, ...fieldValues) {
+        const rule = new Array(fieldIndex).fill('');
+        rule.push(...fieldValues);
+        const filteredPolicies = this.policies.filter(policy => {
+            let flag = true;
+            flag && (flag = ptype === policy.ptype);
+            if (rule.length > 0 && rule[0]) {
+                flag && (flag = rule[0] === policy.v0);
+            }
+            if (rule.length > 1 && rule[1]) {
+                flag && (flag = rule[1] === policy.v1);
+            }
+            if (rule.length > 2 && rule[2]) {
+                flag && (flag = rule[2] === policy.v2);
+            }
+            if (rule.length > 3 && rule[3]) {
+                flag && (flag = rule[3] === policy.v3);
+            }
+            if (rule.length > 4 && rule[4]) {
+                flag && (flag = rule[4] === policy.v4);
+            }
+            if (rule.length > 5 && rule[5]) {
+                flag && (flag = rule[5] === policy.v5);
+            }
+            return !flag;
+        });
+        this.policies = filteredPolicies;
+        const line = new (this.getAdapterLine())();
+        line.ptype = ptype;
+        if (fieldIndex <= 0 && 0 < fieldIndex + fieldValues.length) {
+            line.v0 = fieldValues[0 - fieldIndex];
+        }
+        if (fieldIndex <= 1 && 1 < fieldIndex + fieldValues.length) {
+            line.v1 = fieldValues[1 - fieldIndex];
+        }
+        if (fieldIndex <= 2 && 2 < fieldIndex + fieldValues.length) {
+            line.v2 = fieldValues[2 - fieldIndex];
+        }
+        if (fieldIndex <= 3 && 3 < fieldIndex + fieldValues.length) {
+            line.v3 = fieldValues[3 - fieldIndex];
+        }
+        if (fieldIndex <= 4 && 4 < fieldIndex + fieldValues.length) {
+            line.v4 = fieldValues[4 - fieldIndex];
+        }
+        if (fieldIndex <= 5 && 5 < fieldIndex + fieldValues.length) {
+            line.v5 = fieldValues[5 - fieldIndex];
+        }
+        return this.removePolicyByAdapter(line, filteredPolicies);
+    }
+    loadPolicyLine(line, model) {
+        const lineText = line.ptype +
+            ', ' +
+            [line.v0, line.v1, line.v2, line.v3, line.v4, line.v5]
+                .filter(n => n)
+                .join(', ');
+        casbin_1.Helper.loadPolicyLine(lineText, model);
+    }
+    savePolicyLine(ptype, rule) {
+        const line = new (this.getAdapterLine())();
+        line.ptype = ptype;
+        if (rule.length > 0) {
+            line.v0 = rule[0];
+        }
+        if (rule.length > 1) {
+            line.v1 = rule[1];
+        }
+        if (rule.length > 2) {
+            line.v2 = rule[2];
+        }
+        if (rule.length > 3) {
+            line.v3 = rule[3];
+        }
+        if (rule.length > 4) {
+            line.v4 = rule[4];
+        }
+        if (rule.length > 5) {
+            line.v5 = rule[5];
+        }
+        return line;
+    }
+}
+exports.BaseAdapter = BaseAdapter;
+//# sourceMappingURL=adapter.js.map

package/dist/auth.guard.d.ts

@@ -0,0 +1,11 @@
+import { IGuard, IMidwayContext } from '@midwayjs/core';
+import { CasbinEnforcerService } from './enforcer.service';
+import { CasbinConfigOptions } from './interface';
+export declare class AuthGuard implements IGuard {
+    enforcer: CasbinEnforcerService;
+    casbinConfig: CasbinConfigOptions;
+    canActivate(context: IMidwayContext, supplierClz: any, methodName: string): Promise<boolean>;
+    static asyncSome<T>(array: T[], callback: (value: T, index: number, a: T[]) => Promise<boolean>): Promise<boolean>;
+    static asyncEvery<T>(array: T[], callback: (value: T, index: number, a: T[]) => Promise<boolean>): Promise<boolean>;
+}
+//# sourceMappingURL=auth.guard.d.ts.map

package/dist/auth.guard.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AuthGuard_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthGuard = void 0;
+const core_1 = require("@midwayjs/core");
+const enforcer_service_1 = require("./enforcer.service");
+const constants_1 = require("./constants");
+let AuthGuard = AuthGuard_1 = class AuthGuard {
+    async canActivate(context, supplierClz, methodName) {
+        const permissions = (0, core_1.getPropertyMetadata)(constants_1.PERMISSIONS_METADATA_KEY, supplierClz, methodName);
+        if (!permissions) {
+            return true;
+        }
+        const username = this.casbinConfig.usernameFromContext(context);
+        if (!username) {
+            return false;
+        }
+        const hasPermission = async (user, permission) => {
+            const { possession, resource, action } = permission;
+            const poss = [];
+            if (possession === constants_1.AuthPossession.OWN_ANY) {
+                poss.push(constants_1.AuthPossession.ANY, constants_1.AuthPossession.OWN);
+            }
+            else {
+                poss.push(possession);
+            }
+            return AuthGuard_1.asyncSome(poss, async (p) => {
+                if (p === constants_1.AuthPossession.OWN) {
+                    return permission.isOwn(context);
+                }
+                else {
+                    return this.enforcer.enforce(user, resource, `${action}:${p}`);
+                }
+            });
+        };
+        return await AuthGuard_1.asyncEvery(permissions, async (permission) => hasPermission(username, permission));
+    }
+    static async asyncSome(array, callback) {
+        for (let i = 0; i < array.length; i++) {
+            const result = await callback(array[i], i, array);
+            if (result) {
+                return result;
+            }
+        }
+        return false;
+    }
+    static async asyncEvery(array, callback) {
+        for (let i = 0; i < array.length; i++) {
+            const result = await callback(array[i], i, array);
+            if (!result) {
+                return result;
+            }
+        }
+        return true;
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", enforcer_service_1.CasbinEnforcerService)
+], AuthGuard.prototype, "enforcer", void 0);
+__decorate([
+    (0, core_1.Config)('casbin'),
+    __metadata("design:type", Object)
+], AuthGuard.prototype, "casbinConfig", void 0);
+AuthGuard = AuthGuard_1 = __decorate([
+    (0, core_1.Guard)()
+], AuthGuard);
+exports.AuthGuard = AuthGuard;
+//# sourceMappingURL=auth.guard.js.map

package/dist/configuration.d.ts

@@ -0,0 +1,4 @@
+export declare class CasbinConfiguration {
+    onReady(container: any): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CasbinConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const enforcer_service_1 = require("./enforcer.service");
+let CasbinConfiguration = class CasbinConfiguration {
+    async onReady(container) {
+        await container.getAsync(enforcer_service_1.CasbinEnforcerService);
+    }
+};
+CasbinConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'casbin',
+        importConfigs: [
+            {
+                default: {
+                    casbin: {},
+                },
+            },
+        ],
+    })
+], CasbinConfiguration);
+exports.CasbinConfiguration = CasbinConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const PERMISSIONS_METADATA_KEY = "casbin:permission_metadata";
+export declare enum AuthActionVerb {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    READ = "read"
+}
+export declare enum AuthPossession {
+    ANY = "any",
+    OWN = "own",
+    OWN_ANY = "own|any"
+}
+export declare enum AuthAction {
+    CREATE_ANY = "create:any",
+    CREATE_OWN = "create:own",
+    UPDATE_ANY = "update:any",
+    UPDATE_OWN = "update:own",
+    DELETE_ANY = "delete:any",
+    DELETE_OWN = "delete:own",
+    READ_ANY = "read:any",
+    READ_OWN = "read:own"
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthAction = exports.AuthPossession = exports.AuthActionVerb = exports.PERMISSIONS_METADATA_KEY = void 0;
+exports.PERMISSIONS_METADATA_KEY = 'casbin:permission_metadata';
+var AuthActionVerb;
+(function (AuthActionVerb) {
+    AuthActionVerb["CREATE"] = "create";
+    AuthActionVerb["UPDATE"] = "update";
+    AuthActionVerb["DELETE"] = "delete";
+    AuthActionVerb["READ"] = "read";
+})(AuthActionVerb = exports.AuthActionVerb || (exports.AuthActionVerb = {}));
+var AuthPossession;
+(function (AuthPossession) {
+    AuthPossession["ANY"] = "any";
+    AuthPossession["OWN"] = "own";
+    AuthPossession["OWN_ANY"] = "own|any";
+})(AuthPossession = exports.AuthPossession || (exports.AuthPossession = {}));
+var AuthAction;
+(function (AuthAction) {
+    AuthAction["CREATE_ANY"] = "create:any";
+    AuthAction["CREATE_OWN"] = "create:own";
+    AuthAction["UPDATE_ANY"] = "update:any";
+    AuthAction["UPDATE_OWN"] = "update:own";
+    AuthAction["DELETE_ANY"] = "delete:any";
+    AuthAction["DELETE_OWN"] = "delete:own";
+    AuthAction["READ_ANY"] = "read:any";
+    AuthAction["READ_OWN"] = "read:own";
+})(AuthAction = exports.AuthAction || (exports.AuthAction = {}));
+//# sourceMappingURL=constants.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,7 @@
+import { Permission } from './interface';
+/**
+ * You can define multiple permissions, but only
+ * when all of them satisfied, could you access the route.
+ */
+export declare function UsePermission(...permissions: Permission[]): MethodDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsePermission = void 0;
+const constants_1 = require("./constants");
+const core_1 = require("@midwayjs/core");
+const defaultIsOwn = (ctx) => false;
+/**
+ * You can define multiple permissions, but only
+ * when all of them satisfied, could you access the route.
+ */
+function UsePermission(...permissions) {
+    return (target, propertyKey, descriptor) => {
+        const perms = permissions.map(item => {
+            if (!item.isOwn) {
+                item.isOwn = defaultIsOwn;
+            }
+            return item;
+        });
+        (0, core_1.savePropertyMetadata)(constants_1.PERMISSIONS_METADATA_KEY, perms, target, propertyKey);
+    };
+}
+exports.UsePermission = UsePermission;
+//# sourceMappingURL=decorator.js.map

package/dist/enforcer.service.d.ts

@@ -0,0 +1,13 @@
+import { Enforcer } from 'casbin';
+import { IMidwayContainer } from '@midwayjs/core';
+import { CasbinConfigOptions } from './interface';
+export declare class CasbinEnforcerService {
+    private instance;
+    protected casbinConfig: CasbinConfigOptions;
+    applicationContext: IMidwayContainer;
+    protected init(): Promise<void>;
+    getEnforcer(): Enforcer;
+}
+export interface CasbinEnforcerService extends Enforcer {
+}
+//# sourceMappingURL=enforcer.service.d.ts.map

package/dist/enforcer.service.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CasbinEnforcerService = void 0;
+const casbin_1 = require("casbin");
+const core_1 = require("@midwayjs/core");
+let CasbinEnforcerService = class CasbinEnforcerService {
+    async init() {
+        if (typeof this.casbinConfig.policyAdapter === 'function') {
+            this.casbinConfig.policyAdapter = await this.casbinConfig.policyAdapter(this.applicationContext);
+        }
+        this.instance = await (0, casbin_1.newEnforcer)(this.casbinConfig.modelPath, this.casbinConfig.policyAdapter);
+    }
+    getEnforcer() {
+        return this.instance;
+    }
+};
+__decorate([
+    (0, core_1.Config)('casbin'),
+    __metadata("design:type", Object)
+], CasbinEnforcerService.prototype, "casbinConfig", void 0);
+__decorate([
+    (0, core_1.ApplicationContext)(),
+    __metadata("design:type", Object)
+], CasbinEnforcerService.prototype, "applicationContext", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CasbinEnforcerService.prototype, "init", null);
+CasbinEnforcerService = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], CasbinEnforcerService);
+exports.CasbinEnforcerService = CasbinEnforcerService;
+(0, core_1.delegateTargetAllPrototypeMethod)(CasbinEnforcerService, casbin_1.Enforcer);
+//# sourceMappingURL=enforcer.service.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { CasbinConfiguration as Configuration } from './configuration';
+export * from './enforcer.service';
+export * from './auth.guard';
+export * from './decorator';
+export * from './interface';
+export * from './constants';
+export * from './adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.CasbinConfiguration; } });
+__exportStar(require("./enforcer.service"), exports);
+__exportStar(require("./auth.guard"), exports);
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./adapter"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,16 @@
+import { Adapter } from 'casbin';
+import { AuthActionVerb, AuthPossession } from './constants';
+import { IMidwayContainer, IMidwayContext } from '@midwayjs/core';
+export interface CasbinConfigOptions {
+    modelPath: string;
+    policyAdapter: string | ((applicationContext: IMidwayContainer) => Adapter) | Adapter;
+    usernameFromContext: (ctx: IMidwayContext) => string;
+}
+export interface Permission {
+    resource: string;
+    action: AuthActionVerb | CustomAuthActionVerb;
+    possession: AuthPossession;
+    isOwn?: (ctx: IMidwayContext) => boolean;
+}
+export declare type CustomAuthActionVerb = string;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/index.d.ts

@@ -0,0 +1,9 @@
+import { CasbinConfigOptions } from './dist/index';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    casbin?: Partial<CasbinConfigOptions>;
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@midwayjs/casbin",
+  "description": "midway casbin component",
+  "version": "3.5.3",
+  "main": "dist/index",
+  "typings": "index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@midwayjs/core": "^3.5.3",
+    "@midwayjs/koa": "^3.5.3",
+    "@midwayjs/mock": "^3.5.3"
+  },
+  "dependencies": {
+    "casbin": "5.19.1"
+  },
+  "keywords": [
+    "midway",
+    "component",
+    "casbin"
+  ],
+  "author": "czy88840616 <czy88840616@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "ci": "npm run test",
+    "lint": "mwts check"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/midwayjs/midway.git"
+  }
+}