@web-ts-toolkit/access-router-deco 0.5.0

package/index.js

@@ -0,0 +1,524 @@
+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 __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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AfterDelete: () => AfterDelete,
+  AfterPersist: () => AfterPersist,
+  BaseFilter: () => BaseFilter,
+  BeforeDelete: () => BeforeDelete,
+  Context: () => Context,
+  Decorate: () => Decorate,
+  DecorateAll: () => DecorateAll,
+  DocPermissions: () => DocPermissions,
+  Document: () => Document,
+  EgoseFactory: () => EgoseFactory,
+  EgoseFactoryStatic: () => EgoseFactoryStatic,
+  GlobalPermissions: () => GlobalPermissions,
+  Identifier: () => Identifier,
+  Module: () => Module,
+  Option: () => Option,
+  OverrideFilter: () => OverrideFilter,
+  Permissions: () => Permissions,
+  Prepare: () => Prepare,
+  Request: () => Request,
+  RouteGuard: () => RouteGuard,
+  Router: () => Router2,
+  RouterOptions: () => RouterOptions,
+  Transform: () => Transform,
+  Validate: () => Validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/factory.ts
+var import_express = __toESM(require("express"));
+var import_access_router = __toESM(require("@web-ts-toolkit/access-router"));
+
+// src/constants.ts
+var MODULE_ROUTERS = "routers";
+var MODULE_ROUTER_OPTIONS = "routerOptions";
+var MODULE_OPTIONS = "options";
+var ROOT_ROUTER_WATERMARK = "__root_router__";
+var ROUTER_WATERMARK = "__router__";
+var DEFAULT_MODEL_ROUTER_OPTIONS_WATERMARK = "__default_model_router_options__";
+var MODEL_ROUTER_OPTIONS_WATERMARK = "__model_router_options__";
+var ROUTER_MODEL = "__router_model__";
+var ROUTER_OPTIONS = "__router_options__";
+var ARGS_METADATA = "__args_metadata__";
+var OPTIONS_METADATA = "__opts_metadata__";
+var GLOBAL_PERMISSIONS_WATERMARK = "__global_permissions__";
+var DOC_PERMISSIONS_WATERMARK = "__doc_permissions__";
+var ROUTE_GUARD_WATERMARK = "__route_guard__";
+var BASE_FILTER_WATERMARK = "__base_filter__";
+var VALIDATE_WATERMARK = "__validate__";
+var PREPARE_WATERMARK = "__prepare__";
+var TRANSFORM_WATERMARK = "__transform__";
+var DECORATE_WATERMARK = "__decorate__";
+var DECORATE_ALL_WATERMARK = "__decorate_all__";
+var IDENTIFIER_WATERMARK = "__identifier__";
+var OVERRIDE_FILTER_WATERMARK = "__override_filter__";
+var AFTER_PERSIST_WATERMARK = "__after_persist__";
+var BEFORE_DELETE_WATERMARK = "__before_delete__";
+var AFTER_DELETE_WATERMARK = "__after_delete__";
+var GLOBAL_PERMISSIONS_ARGS = [0 /* REQUEST */];
+var DOC_PERMISSIONS_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var ROUTE_GUARD_ARGS = [3 /* PERMISSIONS */];
+var BASE_FILTER_ARGS = [3 /* PERMISSIONS */];
+var VALIDATE_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var PREPARE_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var TRANSFORM_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var DECORATE_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var DECORATE_ALL_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var OVERRIDE_FILTER_ARGS = [3 /* PERMISSIONS */];
+var AFTER_PERSIST_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var BEFORE_DELETE_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var AFTER_DELETE_ARGS = [1 /* DOCUMENT */, 3 /* PERMISSIONS */, 2 /* CONTEXT */];
+var IDENTIFIER_ARGS = [];
+var ARGS = {
+  globalPermissions: GLOBAL_PERMISSIONS_ARGS,
+  docPermissions: DOC_PERMISSIONS_ARGS,
+  routeGuard: ROUTE_GUARD_ARGS,
+  baseFilter: BASE_FILTER_ARGS,
+  overrideFilter: OVERRIDE_FILTER_ARGS,
+  validate: VALIDATE_ARGS,
+  prepare: PREPARE_ARGS,
+  transform: TRANSFORM_ARGS,
+  afterPersist: AFTER_PERSIST_ARGS,
+  decorate: DECORATE_ARGS,
+  decorateAll: DECORATE_ALL_ARGS,
+  beforeDelete: BEFORE_DELETE_ARGS,
+  afterDelete: AFTER_DELETE_ARGS,
+  identifier: IDENTIFIER_ARGS
+};
+
+// src/metadata.ts
+var isConstructor = (prop) => prop === "constructor";
+var isFunction = (value) => typeof value === "function";
+var getMetadata = (obj, key) => {
+  return Reflect.getMetadata(key, obj) ?? null;
+};
+var getMetadataKeysStartWith = (obj, startKey) => {
+  return Reflect.getMetadataKeys(obj).filter((key) => key.startsWith(startKey));
+};
+var getMethodDescriptor = (obj, method) => {
+  let current = obj;
+  do {
+    const descriptor = Reflect.getOwnPropertyDescriptor(current, method);
+    if (descriptor) return descriptor;
+  } while ((current = Reflect.getPrototypeOf(current)) && current !== Object.prototype);
+  return void 0;
+};
+var getMethodMetadata = (obj, method, key) => {
+  const descriptor = getMethodDescriptor(obj, method);
+  return descriptor ? getMetadata(descriptor.value, key) : null;
+};
+var getMethodMetadataKeysStartWith = (obj, method, startKey) => {
+  const descriptor = getMethodDescriptor(obj, method);
+  return descriptor ? getMetadataKeysStartWith(descriptor.value, startKey) : [];
+};
+function* getAllMethodNames(obj) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = obj;
+  const isMethod = (prop) => {
+    if (seen.has(prop)) return false;
+    const descriptor = Object.getOwnPropertyDescriptor(current, prop);
+    if (descriptor?.set || descriptor?.get) return false;
+    return !isConstructor(prop) && isFunction(current[prop]);
+  };
+  do {
+    for (const name of Object.getOwnPropertyNames(current).filter(isMethod)) {
+      seen.add(name);
+      yield name;
+    }
+  } while ((current = Reflect.getPrototypeOf(current)) && current !== Object.prototype);
+}
+var isRootRouter = (obj) => !!getMetadata(obj, ROOT_ROUTER_WATERMARK);
+var isModelRouter = (obj) => !!getMetadata(obj, ROUTER_WATERMARK);
+var isDefaultModelRouterOptions = (obj) => !!getMetadata(obj, DEFAULT_MODEL_ROUTER_OPTIONS_WATERMARK);
+var isModelRouterOptions = (obj) => !!getMetadata(obj, MODEL_ROUTER_OPTIONS_WATERMARK);
+var isGlobalPermissionsMethod = (obj, method) => !!getMethodMetadata(obj, method, GLOBAL_PERMISSIONS_WATERMARK);
+var isDocPermissionsMethod = (obj, method) => !!getMethodMetadata(obj, method, DOC_PERMISSIONS_WATERMARK);
+var isBaseFilterMethod = (obj, method) => !!getMethodMetadata(obj, method, BASE_FILTER_WATERMARK);
+var isOverrideFilterMethod = (obj, method) => !!getMethodMetadata(obj, method, OVERRIDE_FILTER_WATERMARK);
+var isValidateMethod = (obj, method) => !!getMethodMetadata(obj, method, VALIDATE_WATERMARK);
+var isPrepareMethod = (obj, method) => !!getMethodMetadata(obj, method, PREPARE_WATERMARK);
+var isTransformMethod = (obj, method) => !!getMethodMetadata(obj, method, TRANSFORM_WATERMARK);
+var isAfterPersistMethod = (obj, method) => !!getMethodMetadata(obj, method, AFTER_PERSIST_WATERMARK);
+var isDecorateMethod = (obj, method) => !!getMethodMetadata(obj, method, DECORATE_WATERMARK);
+var isDecorateAllMethod = (obj, method) => !!getMethodMetadata(obj, method, DECORATE_ALL_WATERMARK);
+var isRouteGuardMethod = (obj, method) => !!getMethodMetadata(obj, method, ROUTE_GUARD_WATERMARK);
+var isIdentifierMethod = (obj, method) => !!getMethodMetadata(obj, method, IDENTIFIER_WATERMARK);
+var isBeforeDeleteMethod = (obj, method) => !!getMethodMetadata(obj, method, BEFORE_DELETE_WATERMARK);
+var isAfterDeleteMethod = (obj, method) => !!getMethodMetadata(obj, method, AFTER_DELETE_WATERMARK);
+
+// src/factory.ts
+var toArray = (value) => Array.isArray(value) ? value : [value];
+var compact = (arr) => arr.filter((x) => x != null);
+var HOOK_CONFIG = [
+  { check: isDocPermissionsMethod, optionKey: "docPermissions", aclKey: "docPermissions", array: false },
+  { check: isBaseFilterMethod, optionKey: "baseFilter", aclKey: "baseFilter", array: false },
+  { check: isOverrideFilterMethod, optionKey: "overrideFilter", aclKey: "overrideFilter", array: false },
+  { check: isValidateMethod, optionKey: "validate", aclKey: "validate", array: true },
+  { check: isPrepareMethod, optionKey: "prepare", aclKey: "prepare", array: true },
+  { check: isTransformMethod, optionKey: "transform", aclKey: "transform", array: true },
+  { check: isAfterPersistMethod, optionKey: "afterPersist", aclKey: "afterPersist", array: true },
+  { check: isDecorateMethod, optionKey: "decorate", aclKey: "decorate", array: true },
+  { check: isDecorateAllMethod, optionKey: "decorateAll", aclKey: "decorateAll", array: true },
+  { check: isRouteGuardMethod, optionKey: "routeGuard", aclKey: "operationAccess", array: false },
+  { check: isIdentifierMethod, optionKey: "identifier", aclKey: "resolveIdFilter", array: false },
+  { check: isBeforeDeleteMethod, optionKey: "beforeDelete", aclKey: "beforeDelete", array: false },
+  { check: isAfterDeleteMethod, optionKey: "afterDelete", aclKey: "afterDelete", array: false }
+];
+var EgoseFactoryStatic = class _EgoseFactoryStatic {
+  static create() {
+    return new _EgoseFactoryStatic();
+  }
+  constructor() {
+  }
+  bootstrap(module2, expressApp) {
+    this._expressApp = expressApp;
+    const routers = getMetadata(module2, MODULE_ROUTERS) || [];
+    const routerOptions = getMetadata(module2, MODULE_ROUTER_OPTIONS) || [];
+    const globalOptions = getMetadata(module2, MODULE_OPTIONS) || {};
+    import_access_router.default.setGlobalOptions(globalOptions);
+    this.bootstrapEgose(module2);
+    const expressRouter = import_express.default.Router();
+    const basePath = globalOptions.basePath || "/";
+    for (let x = 0; x < routers.length; x++) {
+      const router = routers[x];
+      if (isRootRouter(router)) this.bootstrapRootRouter(router, expressRouter);
+      else if (isModelRouter(router)) this.bootstrapModelRouter(router, expressRouter);
+    }
+    for (let x = 0; x < routerOptions.length; x++) {
+      const routerOption = routerOptions[x];
+      if (isDefaultModelRouterOptions(routerOption)) this.setDefaultModelRouterOptions(routerOption);
+      else if (isModelRouterOptions(routerOption)) this.setModelRouterOptions(routerOption);
+    }
+    this._expressApp.use(basePath, expressRouter);
+    if (globalOptions.handleErrors) {
+      this._expressApp.use((req, res, next) => {
+        next(new Error("Not Found"));
+      });
+      this._expressApp.use((err, req, res, next) => {
+        res.status(err.status || 500);
+        res.json({ message: err.message, error: err });
+      });
+    }
+  }
+  bootstrapEgose(module2) {
+    const moduleInstance = new module2();
+    this.registerPropertyOptions(moduleInstance, (key, val) => import_access_router.default.setGlobalOption(key, val));
+    const methodNames = new Set(getAllMethodNames(module2.prototype));
+    for (const methodName of methodNames) {
+      if (isGlobalPermissionsMethod(moduleInstance, methodName)) {
+        this.registerMethodHookGlobal(moduleInstance, methodName, "globalPermissions", "globalPermissions", false);
+      }
+    }
+    this._expressApp.use((0, import_access_router.default)());
+  }
+  bootstrapRootRouter(router, expressRouter) {
+    const options = getMetadata(router, ROUTER_OPTIONS);
+    const rootRouter = import_access_router.default.createRouter(options);
+    expressRouter.use(rootRouter.routes);
+  }
+  bootstrapModelRouter(DecoRouter, expressRouter) {
+    const modelName = getMetadata(DecoRouter, ROUTER_MODEL);
+    const options = getMetadata(DecoRouter, ROUTER_OPTIONS);
+    const modelRouter = import_access_router.default.createRouter(modelName, options);
+    const instance = new DecoRouter();
+    this.registerPropertyOptions(instance, (key, val) => import_access_router.default.setModelOption(modelName, key, val));
+    this.registerMethodOptions(
+      instance,
+      DecoRouter.prototype,
+      (key, val) => import_access_router.default.setModelOption(modelName, key, val),
+      (key) => import_access_router.default.getModelOption(modelName, key)
+    );
+    expressRouter.use(modelRouter.routes);
+  }
+  setDefaultModelRouterOptions(DecoRouterOptions) {
+    const options = getMetadata(DecoRouterOptions, ROUTER_OPTIONS);
+    import_access_router.default.setDefaultModelOptions(options);
+    const instance = new DecoRouterOptions();
+    this.registerPropertyOptions(instance, (key, val) => import_access_router.default.setDefaultModelOption(key, val));
+    this.registerMethodOptions(
+      instance,
+      DecoRouterOptions.prototype,
+      (key, val) => import_access_router.default.setDefaultModelOption(key, val),
+      (key) => import_access_router.default.getDefaultModelOption(key),
+      [{ check: isRouteGuardMethod, optionKey: "routeGuard", aclKey: "operationAccess", array: false }]
+    );
+  }
+  setModelRouterOptions(DecoRouterOptions) {
+    const modelName = getMetadata(DecoRouterOptions, ROUTER_MODEL);
+    const options = getMetadata(DecoRouterOptions, ROUTER_OPTIONS);
+    import_access_router.default.setModelOptions(modelName, options);
+    const instance = new DecoRouterOptions();
+    this.registerPropertyOptions(instance, (key, val) => import_access_router.default.setModelOption(modelName, key, val));
+    this.registerMethodOptions(
+      instance,
+      DecoRouterOptions.prototype,
+      (key, val) => import_access_router.default.setModelOption(modelName, key, val),
+      (key) => import_access_router.default.getModelOption(modelName, key)
+    );
+  }
+  registerPropertyOptions(instance, setOption) {
+    const optionProps = getMetadata(instance, OPTIONS_METADATA) || [];
+    for (let x = 0; x < optionProps.length; x++) {
+      const optionProp = optionProps[x];
+      const value = instance[optionProp.propertyKey];
+      setOption(optionProp.optionKey, value);
+    }
+  }
+  registerMethodOptions(instance, prototype, setOption, getOption, filter) {
+    const methodNames = new Set(getAllMethodNames(prototype));
+    const hooks = filter || HOOK_CONFIG;
+    for (const methodName of methodNames) {
+      for (const hook of hooks) {
+        if (hook.check(instance, methodName)) {
+          this.registerMethodHookOnAcl(
+            instance,
+            methodName,
+            hook.optionKey,
+            hook.aclKey,
+            hook.array,
+            setOption,
+            getOption
+          );
+          break;
+        }
+      }
+    }
+  }
+  registerMethodHookGlobal(routerOrOptions, methodName, optionKey, aclKey, arrayType) {
+    const fn = this.wrapMethod(routerOrOptions, methodName, optionKey);
+    if (!fn) return;
+    if (arrayType) {
+      const curr = toArray(compact([import_access_router.default.getGlobalOption(aclKey)]));
+      import_access_router.default.setGlobalOption(aclKey, [...curr, fn]);
+    } else {
+      import_access_router.default.setGlobalOption(aclKey, fn);
+    }
+  }
+  registerMethodHookOnAcl(routerOrOptions, methodName, optionKey, aclKey, arrayType, setOption, getOption) {
+    const keys = getMethodMetadataKeysStartWith(routerOrOptions, methodName, optionKey);
+    for (let x = 0; x < keys.length; x++) {
+      const key = keys[x];
+      const val = getMethodMetadata(routerOrOptions, methodName, key);
+      if (val !== true) continue;
+      const fn = this.wrapMethod(routerOrOptions, methodName, optionKey);
+      if (!fn) continue;
+      const aclOptionKey = optionKey === aclKey ? key : key.replace(optionKey, aclKey);
+      if (arrayType) {
+        const curr = toArray(compact([getOption(aclOptionKey)]));
+        setOption(aclOptionKey, [...curr, fn]);
+      } else {
+        setOption(aclOptionKey, fn);
+      }
+    }
+  }
+  wrapMethod(target, methodName, optionKey) {
+    const dtor = getMethodDescriptor(target, methodName);
+    if (!dtor || typeof dtor.value !== "function") return null;
+    const arglist = ARGS[optionKey] || [];
+    const metalist = Reflect.getMetadata(ARGS_METADATA, target.constructor, methodName) || [];
+    return function(...args) {
+      const ordered = metalist.slice().sort((a, b) => a.index - b.index).map((meta) => {
+        if (meta.type === 0 /* REQUEST */) return this;
+        const index = arglist.findIndex((v) => v === meta.type);
+        return args[index];
+      });
+      return dtor.value.call(target, ...ordered);
+    };
+  }
+};
+var EgoseFactory = EgoseFactoryStatic.create();
+
+// src/decorators/method.decorators.ts
+var import_reflect_metadata = require("reflect-metadata");
+var setMethodMetadata = (watermark, parentOptionKey, optionKey) => {
+  return (target, key, descriptor) => {
+    Reflect.defineMetadata(watermark, true, descriptor.value);
+    const compositeKey = optionKey ? `${parentOptionKey}.${optionKey}` : parentOptionKey;
+    Reflect.defineMetadata(compositeKey, true, descriptor.value);
+    return descriptor;
+  };
+};
+function GlobalPermissions() {
+  return setMethodMetadata(GLOBAL_PERMISSIONS_WATERMARK, "globalPermissions");
+}
+function DocPermissions(optionKey) {
+  return setMethodMetadata(DOC_PERMISSIONS_WATERMARK, "docPermissions", optionKey);
+}
+function BaseFilter(optionKey) {
+  return setMethodMetadata(BASE_FILTER_WATERMARK, "baseFilter", optionKey);
+}
+function OverrideFilter(optionKey) {
+  return setMethodMetadata(OVERRIDE_FILTER_WATERMARK, "overrideFilter", optionKey);
+}
+function Validate(optionKey) {
+  return setMethodMetadata(VALIDATE_WATERMARK, "validate", optionKey);
+}
+function Prepare(optionKey) {
+  return setMethodMetadata(PREPARE_WATERMARK, "prepare", optionKey);
+}
+function Transform(optionKey) {
+  return setMethodMetadata(TRANSFORM_WATERMARK, "transform", optionKey);
+}
+function AfterPersist(optionKey) {
+  return setMethodMetadata(AFTER_PERSIST_WATERMARK, "afterPersist", optionKey);
+}
+function Decorate(optionKey) {
+  return setMethodMetadata(DECORATE_WATERMARK, "decorate", optionKey);
+}
+function DecorateAll(optionKey) {
+  return setMethodMetadata(DECORATE_ALL_WATERMARK, "decorateAll", optionKey);
+}
+function RouteGuard(optionKey) {
+  return setMethodMetadata(ROUTE_GUARD_WATERMARK, "routeGuard", optionKey);
+}
+function Identifier() {
+  return setMethodMetadata(IDENTIFIER_WATERMARK, "identifier");
+}
+function BeforeDelete() {
+  return setMethodMetadata(BEFORE_DELETE_WATERMARK, "beforeDelete");
+}
+function AfterDelete() {
+  return setMethodMetadata(AFTER_DELETE_WATERMARK, "afterDelete");
+}
+
+// src/decorators/property.decorators.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function Option(optionKey) {
+  return (target, propertyKey) => {
+    const opts = Reflect.getMetadata(OPTIONS_METADATA, target) || [];
+    Reflect.defineMetadata(OPTIONS_METADATA, opts.concat({ optionKey: optionKey || propertyKey, propertyKey }), target);
+  };
+}
+
+// src/decorators/parameter.decorators.ts
+var import_reflect_metadata3 = require("reflect-metadata");
+var mergeHookParams = (target, key, index, type) => {
+  const args = Reflect.getMetadata(ARGS_METADATA, target.constructor, key) || [];
+  Reflect.defineMetadata(ARGS_METADATA, args.concat({ index, type }), target.constructor, key);
+};
+function Request() {
+  return (target, key, index) => mergeHookParams(target, key, index, 0 /* REQUEST */);
+}
+function Document() {
+  return (target, key, index) => mergeHookParams(target, key, index, 1 /* DOCUMENT */);
+}
+function Permissions() {
+  return (target, key, index) => mergeHookParams(target, key, index, 3 /* PERMISSIONS */);
+}
+function Context() {
+  return (target, key, index) => mergeHookParams(target, key, index, 2 /* CONTEXT */);
+}
+
+// src/decorators/class.decorators.ts
+var import_reflect_metadata4 = require("reflect-metadata");
+function Module(metadata) {
+  return (target) => {
+    for (const property in metadata) {
+      if (Object.prototype.hasOwnProperty.call(metadata, property)) {
+        Reflect.defineMetadata(property, metadata[property], target);
+      }
+    }
+  };
+}
+function createRootRouter(options) {
+  return (target) => {
+    Reflect.defineMetadata(ROOT_ROUTER_WATERMARK, true, target);
+    Reflect.defineMetadata(ROUTER_OPTIONS, options || {}, target);
+  };
+}
+function createModelRouter(modelName, options) {
+  return (target) => {
+    Reflect.defineMetadata(ROUTER_WATERMARK, true, target);
+    Reflect.defineMetadata(ROUTER_MODEL, modelName, target);
+    Reflect.defineMetadata(ROUTER_OPTIONS, options || {}, target);
+  };
+}
+var Router2 = function Router3(modelNameOrOptions, options) {
+  if (typeof modelNameOrOptions === "string") {
+    return createModelRouter(modelNameOrOptions, options);
+  }
+  if (modelNameOrOptions !== null && typeof modelNameOrOptions === "object") {
+    return createRootRouter(modelNameOrOptions);
+  }
+  throw new TypeError("Router() expects a model name string or a RootRouterOptions object");
+};
+function createDefaultModelRouterOptions(options) {
+  return (target) => {
+    Reflect.defineMetadata(DEFAULT_MODEL_ROUTER_OPTIONS_WATERMARK, true, target);
+    Reflect.defineMetadata(ROUTER_OPTIONS, options || {}, target);
+  };
+}
+function createModelRouterOptions(modelName, options) {
+  return (target) => {
+    Reflect.defineMetadata(MODEL_ROUTER_OPTIONS_WATERMARK, true, target);
+    Reflect.defineMetadata(ROUTER_MODEL, modelName, target);
+    Reflect.defineMetadata(ROUTER_OPTIONS, options || {}, target);
+  };
+}
+var RouterOptions = function RouterOptions2(modelNameOrOptions, options) {
+  if (typeof modelNameOrOptions === "string") {
+    return createModelRouterOptions(modelNameOrOptions, options);
+  }
+  if (modelNameOrOptions !== null && typeof modelNameOrOptions === "object") {
+    return createDefaultModelRouterOptions(modelNameOrOptions);
+  }
+  throw new TypeError("RouterOptions() expects a model name string or a DefaultModelRouterOptions object");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AfterDelete,
+  AfterPersist,
+  BaseFilter,
+  BeforeDelete,
+  Context,
+  Decorate,
+  DecorateAll,
+  DocPermissions,
+  Document,
+  EgoseFactory,
+  EgoseFactoryStatic,
+  GlobalPermissions,
+  Identifier,
+  Module,
+  Option,
+  OverrideFilter,
+  Permissions,
+  Prepare,
+  Request,
+  RouteGuard,
+  Router,
+  RouterOptions,
+  Transform,
+  Validate
+});