@tachybase/resourcer 0.23.8

package/lib/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./utils"), module.exports);
+__reExport(src_exports, require("./middleware"), module.exports);
+__reExport(src_exports, require("./action"), module.exports);
+__reExport(src_exports, require("./resource"), module.exports);
+__reExport(src_exports, require("./resourcer"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./utils"),
+  ...require("./middleware"),
+  ...require("./action"),
+  ...require("./resource"),
+  ...require("./resourcer")
+});

package/lib/middleware.d.ts

@@ -0,0 +1,32 @@
+import { ActionName } from './action';
+import { HandlerType } from './resourcer';
+export type MiddlewareType = string | string[] | HandlerType | HandlerType[] | MiddlewareOptions | MiddlewareOptions[];
+export interface MiddlewareOptions {
+    /**
+     * actions 白名单，默认有 list、get、create、update、delete
+     */
+    only?: Array<ActionName>;
+    /**
+     * actions 黑名单，默认有 list、get、create、update、delete
+     */
+    except?: Array<ActionName>;
+    handler?: HandlerType | Function;
+    [key: string]: any;
+}
+export declare class Middleware {
+    protected options: MiddlewareOptions;
+    private middlewares;
+    constructor(options: MiddlewareOptions | Function);
+    getHandler(): (ctx: any, next: any) => any;
+    use(middleware: HandlerType): void;
+    disuse(middleware: HandlerType): void;
+    canAccess(name: ActionName): boolean;
+    static toInstanceArray(middlewares: any): Middleware[];
+}
+export default Middleware;
+export declare function branch(map: {
+    [key: string]: HandlerType;
+}, reducer: (ctx: any) => string, options?: {
+    keyNotFound?(ctx: any, next: any): void;
+    handlerNotSet?(ctx: any, next: any): void;
+}): HandlerType;

package/lib/middleware.js

@@ -0,0 +1,113 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  Middleware: () => Middleware,
+  branch: () => branch,
+  default: () => middleware_default
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_utils = require("@tachybase/utils");
+var import_koa_compose = __toESM(require("koa-compose"));
+const _Middleware = class _Middleware {
+  options;
+  middlewares = [];
+  constructor(options) {
+    options = (0, import_utils.requireModule)(options);
+    if (typeof options === "function") {
+      this.options = { handler: options };
+    } else {
+      this.options = options;
+    }
+  }
+  getHandler() {
+    const handler = (0, import_utils.requireModule)(this.options.handler);
+    if (typeof handler !== "function") {
+      throw new Error("Handler must be a function!");
+    }
+    return (ctx, next) => (0, import_koa_compose.default)([handler, ...this.middlewares])(ctx, next);
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  disuse(middleware) {
+    this.middlewares.splice(this.middlewares.indexOf(middleware), 1);
+  }
+  canAccess(name) {
+    const { only = [], except = [] } = this.options;
+    if (only.length > 0) {
+      return only.includes(name);
+    }
+    if (except.length > 0) {
+      return !except.includes(name);
+    }
+    return true;
+  }
+  static toInstanceArray(middlewares) {
+    if (!middlewares) {
+      return [];
+    }
+    if (!Array.isArray(middlewares)) {
+      middlewares = [middlewares];
+    }
+    return middlewares.map((middleware) => {
+      if (middleware instanceof _Middleware) {
+        return middleware;
+      }
+      if (typeof middleware === "object") {
+        return new _Middleware(middleware);
+      }
+      if (typeof middleware === "function") {
+        return new _Middleware({ handler: middleware });
+      }
+    });
+  }
+};
+__name(_Middleware, "Middleware");
+let Middleware = _Middleware;
+var middleware_default = Middleware;
+function branch(map = {}, reducer, options = {}) {
+  return (ctx, next) => {
+    const key = reducer(ctx);
+    if (!key) {
+      return options.keyNotFound ? options.keyNotFound(ctx, next) : ctx.throw(404);
+    }
+    const handler = map[key];
+    if (!handler) {
+      return options.handlerNotSet ? options.handlerNotSet(ctx, next) : ctx.throw(404);
+    }
+    return handler(ctx, next);
+  };
+}
+__name(branch, "branch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Middleware,
+  branch
+});

package/lib/resource.d.ts

@@ -0,0 +1,53 @@
+import Action, { ActionName, ActionType } from './action';
+import Middleware, { MiddlewareType } from './middleware';
+import { HandlerType, Resourcer } from './resourcer';
+export type ResourceType = 'single' | 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+export interface ResourceOptions {
+    /**
+     * 资源名称
+     */
+    name: string;
+    /**
+     * 资源类型，默认为 single
+     */
+    type?: ResourceType;
+    /**
+     * 资源的行为
+     */
+    actions?: {
+        [key: string]: ActionType;
+    };
+    /**
+     * actions 白名单，默认有 list、get、create、update、delete
+     */
+    only?: Array<ActionName>;
+    /**
+     * actions 黑名单，默认有 list、get、create、update、delete
+     */
+    except?: Array<ActionName>;
+    /**
+     * 中间件
+     */
+    middleware?: MiddlewareType;
+    /**
+     * 中间件
+     */
+    middlewares?: MiddlewareType;
+    /**
+     * 额外的一些参数
+     */
+    [key: string]: any;
+}
+export declare class Resource {
+    readonly resourcer: Resourcer;
+    readonly middlewares: Middleware[];
+    readonly actions: Map<ActionName, Action>;
+    readonly options: ResourceOptions;
+    readonly except: Array<ActionName>;
+    constructor(options: ResourceOptions, resourcer: Resourcer);
+    getName(): string;
+    getExcept(): ActionName[];
+    addAction(name: ActionName, handler: HandlerType): void;
+    getAction(action: ActionName): Action;
+}
+export default Resource;

package/lib/resource.js

@@ -0,0 +1,98 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resource_exports = {};
+__export(resource_exports, {
+  Resource: () => Resource,
+  default: () => resource_default
+});
+module.exports = __toCommonJS(resource_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_action = __toESM(require("./action"));
+var import_middleware = __toESM(require("./middleware"));
+const _Resource = class _Resource {
+  resourcer;
+  middlewares;
+  actions = /* @__PURE__ */ new Map();
+  options;
+  except;
+  constructor(options, resourcer) {
+    const { middleware, middlewares, actions = {}, only = [], except = [] } = options;
+    this.options = options;
+    this.resourcer = resourcer;
+    this.middlewares = import_middleware.default.toInstanceArray(middleware || middlewares);
+    let excludes = [];
+    for (const [name, handler] of resourcer.getRegisteredHandlers()) {
+      if (!actions[name]) {
+        actions[name] = handler;
+      }
+    }
+    if (except.length > 0) {
+      excludes = except;
+    } else if (only.length > 0) {
+      excludes = Object.keys(actions).filter((name) => !only.includes(name));
+    }
+    this.except = excludes;
+    this.actions = import_action.default.toInstanceMap(import_lodash.default.omit(actions, excludes), this);
+  }
+  getName() {
+    return this.options.name;
+  }
+  getExcept() {
+    return this.except;
+  }
+  addAction(name, handler) {
+    if (this.except.includes(name)) {
+      throw new Error(`${name} action is not allowed`);
+    }
+    if (this.actions.has(name)) {
+      throw new Error(`${name} action already exists`);
+    }
+    const action = new import_action.default(handler);
+    action.setName(name);
+    action.setResource(this);
+    action.middlewares.unshift(...this.middlewares);
+    this.actions.set(name, action);
+  }
+  getAction(action) {
+    if (this.except.includes(action)) {
+      throw new Error(`${action} action is not allowed`);
+    }
+    if (!this.actions.has(action)) {
+      throw new Error(`${action} action does not exist`);
+    }
+    return this.actions.get(action);
+  }
+};
+__name(_Resource, "Resource");
+let Resource = _Resource;
+var resource_default = Resource;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Resource
+});

package/lib/resourcer.d.ts

@@ -0,0 +1,216 @@
+import { Toposort, ToposortOptions } from '@tachybase/utils';
+import Action, { ActionName } from './action';
+import Resource, { ResourceOptions } from './resource';
+import { ParsedParams } from './utils';
+export interface ResourcerContext {
+    resourcer?: Resourcer;
+    action?: Action;
+    [key: string]: any;
+}
+export interface KoaMiddlewareOptions {
+    skipIfDataSourceExists?: boolean;
+    /**
+     * 前缀
+     */
+    prefix?: string;
+    /**
+     * 自定义 resource name 的获取规则
+     *
+     * 默认规则 relatedTable ? relatedTable.table : table
+     */
+    nameRule?: (params: ParsedParams) => string;
+    /**
+     * 自定义 action name
+     *
+     * 默认为
+     *
+     * - list 查看列表
+     * - create 新增数据
+     * - get 查看数据详情
+     * - update 更新数据
+     * - delete 删除数据
+     */
+    accessors?: {
+        /**
+         * 查看列表
+         */
+        list?: string;
+        /**
+         * 新增数据
+         */
+        create?: string;
+        /**
+         * 查看数据详情
+         */
+        get?: string;
+        /**
+         * 更新数据
+         */
+        update?: string;
+        /**
+         * 删除数据
+         */
+        delete?: string;
+    };
+}
+export interface ResourcerOptions {
+    /**
+     * 前缀
+     */
+    prefix?: string;
+    /**
+     * 自定义 action name
+     *
+     * 默认为
+     *
+     * - list 查看列表
+     * - create 新增数据
+     * - get 查看数据详情
+     * - update 更新数据
+     * - delete 删除数据
+     */
+    accessors?: {
+        /**
+         * 查看列表
+         */
+        list?: string;
+        /**
+         * 新增数据
+         */
+        create?: string;
+        /**
+         * 查看数据详情
+         */
+        get?: string;
+        /**
+         * 更新数据
+         */
+        update?: string;
+        /**
+         * 删除数据
+         */
+        delete?: string;
+    };
+}
+export interface ExecuteOptions {
+    /**
+     * 资源名称
+     */
+    resource: string;
+    /**
+     * 自定义 action name
+     *
+     * 默认
+     * - list 查看列表
+     * - create 新增数据
+     * - get 查看数据详情
+     * - update 更新数据
+     * - delete 删除数据
+     */
+    action: ActionName;
+}
+export type HandlerType = (ctx: ResourcerContext, next: () => Promise<any>) => any;
+export interface Handlers {
+    [key: string]: HandlerType;
+}
+export interface ImportOptions {
+    /**
+     * 指定配置所在路径
+     */
+    directory: string;
+    /**
+     * 文件后缀，默认值 ['js', 'ts', 'json']
+     */
+    extensions?: string[];
+}
+export declare class Resourcer {
+    /**
+     * @internal
+     */
+    readonly options: ResourcerOptions;
+    protected resources: Map<string, Resource>;
+    /**
+     * 全局定义的 action handlers
+     */
+    protected handlers: Map<ActionName, any>;
+    protected actionHandlers: Map<ActionName, any>;
+    protected middlewareHandlers: Map<string, any>;
+    protected middlewares: Toposort<any>;
+    middlewareSourceMap: WeakMap<HandlerType | HandlerType[], string>;
+    constructor(options?: ResourcerOptions);
+    /**
+     * 载入指定目录下的 resource 配置（配置的文件驱动）
+     *
+     * TODO: 配置的文件驱动现在会全部初始化，大数据时可能存在性能瓶颈，后续可以加入动态加载
+     *
+     * @param {object}   [options]
+     * @param {string}   [options.directory] 指定配置所在路径
+     * @param {array}    [options.extensions = ['js', 'ts', 'json']] 文件后缀
+     *
+     */
+    import(options: ImportOptions): Promise<Map<string, Resource>>;
+    /**
+     * resource 配置
+     *
+     * @param name
+     * @param options
+     */
+    define(options: ResourceOptions): Resource;
+    isDefined(name: string): boolean;
+    /**
+     * @internal
+     */
+    removeResource(name: any): boolean;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link this.registerActionHandler()} instead.
+     * @deprecated
+     */
+    registerAction(name: ActionName, handler: HandlerType): void;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link this.registerActionHandlers()} instead.
+     * @deprecated
+     */
+    registerActions(handlers: Handlers): void;
+    /**
+     * 注册全局的 action handlers
+     *
+     * @param handlers
+     */
+    registerActionHandlers(handlers: Handlers): void;
+    registerActionHandler(name: ActionName, handler: HandlerType): void;
+    /**
+     * @internal
+     */
+    getRegisteredHandler(name: ActionName): any;
+    /**
+     * @internal
+     */
+    getRegisteredHandlers(): Map<ActionName, any>;
+    /**
+     * @internal
+     */
+    getResource(name: string): Resource;
+    /**
+     * @internal
+     */
+    getAction(name: string, action: ActionName): Action;
+    /**
+     * @internal
+     */
+    getMiddlewares(): any[];
+    use(middlewares: HandlerType | HandlerType[], options?: ToposortOptions): void;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link this.middleware()} instead.
+     * @deprecated
+     */
+    restApiMiddleware({ prefix, accessors, skipIfDataSourceExists }?: KoaMiddlewareOptions): (ctx: ResourcerContext, next: () => Promise<any>) => Promise<any>;
+    middleware(options?: KoaMiddlewareOptions): (ctx: ResourcerContext, next: () => Promise<any>) => Promise<any>;
+    /**
+     * @internal
+     */
+    execute(options: ExecuteOptions, context?: ResourcerContext, next?: any): Promise<any>;
+}
+export default Resourcer;