vona-module-a-permission 5.0.1

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/dist/.metadata/index.d.ts

@@ -0,0 +1,121 @@
+import type { TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+/** bean: begin */
+export * from '../bean/bean.permission.ts';
+import 'vona';
+declare module 'vona' {
+}
+declare module 'vona-module-a-permission' {
+    interface BeanPermission {
+    }
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanPermission } from '../bean/bean.permission.ts';
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        'permission': BeanPermission;
+    }
+}
+/** bean: end */
+/** event: begin */
+export * from '../bean/event.retrievePermissions.ts';
+import 'vona';
+declare module 'vona' {
+}
+declare module 'vona-module-a-permission' {
+    interface EventRetrievePermissions {
+    }
+    interface EventRetrievePermissions {
+        get $beanFullName(): 'a-permission.event.retrievePermissions';
+        get $onionName(): 'a-permission:retrievePermissions';
+    }
+}
+/** event: end */
+/** event: begin */
+import type { EventRetrievePermissions } from '../bean/event.retrievePermissions.ts';
+export interface IModuleEvent {
+    'retrievePermissions': EventRetrievePermissions;
+}
+/** event: end */
+/** event: begin */
+import type { TypeEventRetrievePermissionsData, TypeEventRetrievePermissionsResult } from '../bean/event.retrievePermissions.ts';
+import type { EventOn } from 'vona-module-a-event';
+declare module 'vona-module-a-event' {
+    interface IEventRecord {
+        'a-permission:retrievePermissions': EventOn<TypeEventRetrievePermissionsData, TypeEventRetrievePermissionsResult>;
+    }
+}
+/** event: end */
+/** summerCache: begin */
+export * from '../bean/summerCache.permission.ts';
+import { type IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+declare module 'vona-module-a-summer' {
+    interface ISummerCacheRecord {
+        'a-permission:permission': IDecoratorSummerCacheOptions;
+    }
+}
+declare module 'vona-module-a-permission' {
+    interface SummerCachePermission {
+    }
+    interface SummerCachePermission {
+        get $beanFullName(): 'a-permission.summerCache.permission';
+        get $onionName(): 'a-permission:permission';
+        get $onionOptions(): IDecoratorSummerCacheOptions;
+    }
+}
+/** summerCache: end */
+/** summerCache: begin */
+import type { SummerCachePermission } from '../bean/summerCache.permission.ts';
+export interface IModuleSummerCache {
+    'permission': SummerCachePermission;
+}
+/** summerCache: end */
+/** dto: begin */
+export * from '../dto/permissions.tsx';
+import type { IDtoOptionsPermissions } from '../dto/permissions.tsx';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+    interface IDtoRecord {
+        'a-permission:permissions': IDtoOptionsPermissions;
+    }
+}
+declare module 'vona-module-a-permission' {
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoPermissions } from '../dto/permissions.tsx';
+declare module 'vona-module-a-permission' {
+    interface IDtoOptionsPermissions {
+        fields?: TypeEntityOptionsFields<DtoPermissions, IDtoOptionsPermissions[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+export declare class ScopeModuleAPermission extends BeanScopeBase {
+}
+export interface ScopeModuleAPermission {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    event: IModuleEvent;
+    summerCache: IModuleSummerCache;
+}
+import 'vona';
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-permission': ScopeModuleAPermission;
+    }
+    interface IBeanScopeContainer {
+        permission: ScopeModuleAPermission;
+    }
+    interface IBeanScopeConfig {
+        'a-permission': ReturnType<typeof config>;
+    }
+}
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-permission";
+export { ScopeModuleAPermission as ScopeModule } from './index.ts';

package/dist/bean/bean.permission.d.ts

@@ -0,0 +1,10 @@
+import type { ICachingActionKeyInfo } from 'vona-module-a-caching';
+import type { IOpenapiPermissions, IResourceRecord } from 'vona-module-a-openapi';
+import { BeanBase } from 'vona';
+export declare class BeanPermission extends BeanBase {
+    clearAllCaches(): Promise<void>;
+    protected retrievePermissionsCacheKey(info: ICachingActionKeyInfo): string;
+    retrievePermissions(resource: keyof IResourceRecord): Promise<IOpenapiPermissions>;
+    getPermissionsDefault(resource: keyof IResourceRecord): Promise<IOpenapiPermissions>;
+    private _getPermissionOfAction;
+}

package/dist/bean/event.retrievePermissions.d.ts

@@ -0,0 +1,8 @@
+import type { IOpenapiPermissions, IResourceRecord } from 'vona-module-a-openapi';
+import { BeanEventBase } from 'vona-module-a-event';
+export interface TypeEventRetrievePermissionsData {
+    resource: keyof IResourceRecord;
+}
+export type TypeEventRetrievePermissionsResult = IOpenapiPermissions;
+export declare class EventRetrievePermissions extends BeanEventBase<TypeEventRetrievePermissionsData, TypeEventRetrievePermissionsResult> {
+}

package/dist/bean/summerCache.permission.d.ts

@@ -0,0 +1,7 @@
+import type { ISummerCacheGet, TSummerCacheActionOptions } from 'vona-module-a-summer';
+import { BeanSummerCacheBase } from 'vona-module-a-summer';
+export type TSummerCachePermissionKey = any;
+export type TSummerCachePermissionData = any;
+export declare class SummerCachePermission extends BeanSummerCacheBase<TSummerCachePermissionKey, TSummerCachePermissionData> implements ISummerCacheGet<TSummerCachePermissionKey, TSummerCachePermissionData> {
+    getNative(_key?: TSummerCachePermissionKey, _options?: TSummerCacheActionOptions<TSummerCachePermissionKey, TSummerCachePermissionData>): Promise<TSummerCachePermissionData | undefined>;
+}

package/dist/config/config.d.ts

@@ -0,0 +1,6 @@
+import type { VonaApplication } from 'vona';
+export declare function config(_app: VonaApplication): {
+    permission: {
+        actionsIgnore: string[];
+    };
+};

package/dist/dto/permissions.d.ts

@@ -0,0 +1,10 @@
+import type { IOpenapiPermissionModeActionActions, IOpenapiPermissions } from 'vona-module-a-openapi';
+import type { IRoleIdRecord, IRoleNameRecord } from 'vona-module-a-user';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsPermissions extends IDecoratorDtoOptions {
+}
+export declare class DtoPermissions implements IOpenapiPermissions {
+    roleIds?: (keyof IRoleIdRecord)[];
+    roleNames?: (keyof IRoleNameRecord)[];
+    actions?: IOpenapiPermissionModeActionActions;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/dist/index.js

@@ -0,0 +1,122 @@
+import { BeanInfo, BeanBase, beanFullNameFromOnionName, appResource, appMetadata, BeanScopeBase } from 'vona';
+import { __decorate, __metadata } from 'tslib';
+import { catchError } from '@cabloy/utils';
+import { Bean, Scope } from 'vona-module-a-bean';
+import { Caching } from 'vona-module-a-caching';
+import { SymbolUseOnionOptionsRouteReal } from 'vona-module-a-onion';
+import { recordResourceNameToRoutePath, composeGuards, Dto } from 'vona-module-a-web';
+import { Event, BeanEventBase } from 'vona-module-a-event';
+import { SummerCache, BeanSummerCacheBase } from 'vona-module-a-summer';
+import { Api, v } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+let BeanPermission = class BeanPermission extends BeanBase {
+  async clearAllCaches() {
+    const cacheOpenapiSchema = this.bean.summer.cache(beanFullNameFromOnionName('a-permission:permission', 'summerCache'));
+    await cacheOpenapiSchema.clear();
+  }
+  retrievePermissionsCacheKey(info) {
+    const resource = info.args[0];
+    const userId = this.ctx.passport.user?.id;
+    return `${resource}_${userId}`;
+  }
+  async retrievePermissions(resource) {
+    return await this.scope.event.retrievePermissions.emit({
+      resource
+    }, async () => {
+      return await this.getPermissionsDefault(resource);
+    });
+  }
+  async getPermissionsDefault(resource) {
+    const routePathInfo = recordResourceNameToRoutePath[resource];
+    if (!routePathInfo) throw new Error(`not found routePath of resource: ${resource}`);
+    // controller options
+    const controller = routePathInfo.controller;
+    // controller options
+    const beanOptions = appResource.getBean(controller);
+    if (!beanOptions) throw new Error('invalid controller');
+    const controllerBeanFullName = beanOptions.beanFullName;
+    // descs
+    const descs = Object.getOwnPropertyDescriptors(controller.prototype);
+    const actionsIgnore = this.scope.config.permission.actionsIgnore;
+    const actionKeys = Object.keys(descs).filter(actionKey => !['constructor'].includes(actionKey) && !actionsIgnore.includes(actionKey));
+    // actions
+    const permissionsActions = {};
+    for (const actionKey of actionKeys) {
+      const desc = descs[actionKey];
+      if (!desc.value || typeof desc.value !== 'function') continue;
+      const routeReal = appMetadata.getMetadata(SymbolUseOnionOptionsRouteReal, controller.prototype, actionKey);
+      const route = {
+        controller,
+        controllerBeanFullName,
+        action: actionKey,
+        route: routeReal
+      };
+      permissionsActions[actionKey] = await this._getPermissionOfAction(route);
+    }
+    return {
+      actions: permissionsActions
+    };
+  }
+  async _getPermissionOfAction(route) {
+    const routePrev = this.ctx.route;
+    this.ctx.route = route;
+    const composer = composeGuards(this.app, route);
+    const [_, error] = await catchError(() => {
+      return composer(this.ctx);
+    });
+    this.ctx.route = routePrev;
+    return !error;
+  }
+};
+__decorate([Caching.get({
+  cacheName: 'a-permission:permission',
+  cacheKeyFn: 'retrievePermissionsCacheKey'
+}), __metadata("design:type", Function), __metadata("design:paramtypes", [Object]), __metadata("design:returntype", Promise)], BeanPermission.prototype, "retrievePermissions", null);
+BeanPermission = __decorate([Bean(), BeanInfo({
+  module: "a-permission"
+})], BeanPermission);
+
+let EventRetrievePermissions = class EventRetrievePermissions extends BeanEventBase {};
+EventRetrievePermissions = __decorate([Event(), BeanInfo({
+  module: "a-permission"
+})], EventRetrievePermissions);
+
+let SummerCachePermission = class SummerCachePermission extends BeanSummerCacheBase {
+  async getNative(_key, _options) {}
+};
+SummerCachePermission = __decorate([SummerCache({
+  preset: 'mem'
+}), BeanInfo({
+  module: "a-permission"
+})], SummerCachePermission);
+
+let DtoPermissions = class DtoPermissions {
+  constructor() {
+    this.roleIds = void 0;
+    this.roleNames = void 0;
+    this.actions = void 0;
+  }
+};
+__decorate([Api.field(v.optional(), v.array(v.tableIdentity())), __metadata("design:type", Array)], DtoPermissions.prototype, "roleIds", void 0);
+__decorate([Api.field(v.optional(), v.array(z.string())), __metadata("design:type", Array)], DtoPermissions.prototype, "roleNames", void 0);
+__decorate([Api.field(v.optional()), __metadata("design:type", Object)], DtoPermissions.prototype, "actions", void 0);
+DtoPermissions = __decorate([Dto(), BeanInfo({
+  module: "a-permission"
+})], DtoPermissions);
+
+function config(_app) {
+  return {
+    permission: {
+      actionsIgnore: ['select']
+    }
+  };
+}
+
+let ScopeModuleAPermission = class ScopeModuleAPermission extends BeanScopeBase {};
+ScopeModuleAPermission = __decorate([Scope(), BeanInfo({
+  module: "a-permission"
+})], ScopeModuleAPermission);
+/** scope: end */
+
+export { BeanPermission, DtoPermissions, EventRetrievePermissions, ScopeModuleAPermission, SummerCachePermission, config };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "vona-module-a-permission",
+  "type": "module",
+  "version": "5.0.1",
+  "title": "a-permission",
+  "vonaModule": {
+    "dependencies": {}
+  },
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
+  }
+}