balda-js 0.0.51 → 0.0.53

package/lib/index.cjs

@@ -477,6 +477,39 @@ flagDecorator.number = (options) => {
   return flagDecorator({ ...options, type: "number" });
 };
 var flag = flagDecorator;
+var NativePath = class {
+  join(...paths) {
+    switch (runtime.type) {
+      case "node":
+      case "bun":
+      case "deno":
+        return path__default.default.join(...paths);
+      default:
+        throw new Error("Unsupported runtime");
+    }
+  }
+  extName(inputPath) {
+    switch (runtime.type) {
+      case "bun":
+      case "node":
+      case "deno":
+        return path__default.default.extname(inputPath);
+      default:
+        throw new Error("Unsupported runtime");
+    }
+  }
+  resolve(...paths) {
+    switch (runtime.type) {
+      case "bun":
+      case "node":
+      case "deno":
+        return path__default.default.resolve(...paths);
+      default:
+        throw new Error("Unsupported runtime");
+    }
+  }
+};
+var nativePath = new NativePath();
 
 // src/server/router/router.ts
 var Node = class {
@@ -725,45 +758,28 @@ var Router = class _Router {
   }
 };
 var router = new Router();
-var NativePath = class {
-  join(...paths) {
-    switch (runtime.type) {
-      case "node":
-      case "bun":
-      case "deno":
-        return path__default.default.join(...paths);
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-  extName(inputPath) {
-    switch (runtime.type) {
-      case "bun":
-      case "node":
-      case "deno":
-        return path__default.default.extname(inputPath);
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-  resolve(...paths) {
-    switch (runtime.type) {
-      case "bun":
-      case "node":
-      case "deno":
-        return path__default.default.resolve(...paths);
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativePath = new NativePath();
 
 // src/decorators/controller/controller.ts
+var createPolicyMiddleware = (policies) => {
+  return async (req, res, next) => {
+    for (const policy of policies) {
+      const allowed = await policy.manager.canAccess(
+        policy.scope,
+        policy.handler,
+        req
+      );
+      if (!allowed) {
+        return res.unauthorized({ error: "Unauthorized" });
+      }
+    }
+    return next();
+  };
+};
 var controller = (path2, swaggerOptions) => {
   return (target) => {
     const classMeta = MetadataStore.get(target.prototype, "__class__");
     const classMiddlewares = classMeta?.middlewares || [];
+    const classPolicies = classMeta?.policies || [];
     const metaMap = MetadataStore.getAll(target.prototype);
     const instance = new target();
     for (const [propertyKey, meta] of metaMap.entries()) {
@@ -772,7 +788,16 @@ var controller = (path2, swaggerOptions) => {
       }
       const handler = target.prototype[propertyKey].bind(instance);
       const fullPath = path2 ? nativePath.join(path2, meta.route.path) : meta.route.path;
-      const allMiddlewares = [...classMiddlewares, ...meta.middlewares || []];
+      const allPolicies = [
+        ...classPolicies,
+        ...meta.policies || []
+      ];
+      const policyMiddleware = allPolicies.length > 0 ? [createPolicyMiddleware(allPolicies)] : [];
+      const allMiddlewares = [
+        ...classMiddlewares,
+        ...policyMiddleware,
+        ...meta.middlewares || []
+      ];
       router.addOrUpdate(
         meta.route.method,
         fullPath,
@@ -5426,12 +5451,55 @@ var Server = class {
 var BasePlugin = class {
 };
 
+// src/server/policy/policy_decorator.ts
+var createPolicyDecorator = (manager) => {
+  return (scope, handler) => {
+    return (target, propertyKey, descriptor) => {
+      const policyMeta = { scope, handler, manager };
+      if (typeof propertyKey === "undefined") {
+        let meta2 = MetadataStore.get(target.prototype, "__class__");
+        if (!meta2) {
+          meta2 = { policies: [] };
+        }
+        if (!meta2.policies) {
+          meta2.policies = [];
+        }
+        meta2.policies.push(policyMeta);
+        MetadataStore.set(target.prototype, "__class__", meta2);
+        return target;
+      }
+      let meta = MetadataStore.get(target, propertyKey);
+      if (!meta) {
+        meta = { policies: [] };
+      }
+      if (!meta.policies) {
+        meta.policies = [];
+      }
+      meta.policies.push(policyMeta);
+      MetadataStore.set(target, propertyKey, meta);
+      return descriptor;
+    };
+  };
+};
+
 // src/server/policy/policy_manager.ts
 var PolicyManager = class {
   providers;
   constructor(providers) {
     this.providers = providers;
   }
+  /**
+   * Creates a decorator for the policy manager with typed parameters
+   */
+  createDecorator() {
+    return createPolicyDecorator(this);
+  }
+  /**
+   * Checks if the user has access to the given scope and handler
+   * @param scope - The scope to check access for
+   * @param handler - The handler to check access for
+   * @param args - The arguments to pass to the handler
+   */
   canAccess(scope, handler, ...args2) {
     const provider = this.providers[scope];
     if (!provider) {
@@ -5464,6 +5532,7 @@ exports.commandRegistry = commandRegistry;
 exports.controller = controller;
 exports.cookie = cookie;
 exports.cors = cors;
+exports.createPolicyDecorator = createPolicyDecorator;
 exports.cron = cron;
 exports.defineLoggerConfig = defineLoggerConfig;
 exports.defineQueueConfiguration = defineQueueConfiguration;