@adonisjs/route-model-binding/build/index.js

Route model binding for AdonisJS

import {
  __name,
  resolveRouteHandler
} from "./chunk-FAJSNHSW.js";

// configure.ts
async function configure(command) {
  const codemods = await command.createCodemods();
  await codemods.registerMiddleware("router", [
    {
      path: "@adonisjs/route-model-binding/rmb_middleware"
    }
  ]);
  await codemods.updateRcFile((rcFile) => {
    rcFile.addProvider("@adonisjs/route-model-binding/rmb_provider");
  });
}
__name(configure, "configure");

// src/decorators/bind.ts
import { defineStaticProperty } from "@poppinss/utils";
function bind() {
  return function(target, method) {
    const methodParams = Reflect.getMetadata("design:paramtypes", target, method);
    if (!target.constructor.hasOwnProperty("containerProvider")) {
      const containerProvider = /* @__PURE__ */ __name((binding, property, resolver, defaultProvider, runtimeValues) => {
        if (runtimeValues) {
          for (const modelInstance of Object.values(runtimeValues[0].resources)) {
            runtimeValues.push(modelInstance);
          }
        }
        return defaultProvider(binding, property, resolver, runtimeValues);
      }, "containerProvider");
      defineStaticProperty(target.constructor, "containerProvider", {
        initialValue: containerProvider,
        strategy: "inherit"
      });
    }
    if (!target.constructor.hasOwnProperty("bindings")) {
      defineStaticProperty(target.constructor, "bindings", {
        initialValue: {},
        strategy: "inherit"
      });
      Object.defineProperty(target, "getHandlerArguments", {
        value: async function(ctx, app) {
          const handler = ctx.route.handler;
          if (!handler || typeof handler === "function") {
            return [
              ctx
            ];
          }
          const resolvedHandler = await resolveRouteHandler(handler.reference, app);
          const bindings = this.constructor.bindings[resolvedHandler.method];
          if (!bindings) {
            return [
              ctx
            ];
          }
          return bindings.reduce((result, _, index) => {
            const param = ctx.route.meta.resolvedParams[index];
            if (param) {
              result.push(ctx.resources[param.name]);
            }
            return result;
          }, [
            ctx
          ]);
        }
      });
    }
    target.constructor.bindings[method] = target.constructor.bindings[method] || [];
    methodParams.forEach((param, index) => {
      if (index !== 0) {
        target.constructor.bindings[method].push(param);
      }
    });
  };
}
__name(bind, "bind");
export {
  bind,
  configure
};
//# sourceMappingURL=index.js.map