serverless-plugin-module-registry 1.0.12 → 1.0.13

package/dist/index.d.ts

@@ -458,6 +458,18 @@ declare class ServerlessModuleRegistryPlugin {
      * Runs BEFORE main deployment to ensure table exists
      */
     private deployInternalInfrastructure;
+    /**
+     * Standalone command handler: deploy module registry infrastructure
+     * Bypasses the `enabled: false` check — deploys the DynamoDB table, EventBridge bus, SQS, and Lambda processors.
+     * Usage: `npx serverless@4 registryDeployInfra --stage dev --region sa-east-1`
+     */
+    private registryDeployInfraHandler;
+    /**
+     * Standalone command handler: validate/package module registry infrastructure
+     * Validates configuration and checks that internal-infrastructure directory exists.
+     * Usage: `npx serverless@4 registryPackageInfra --stage dev --region sa-east-1`
+     */
+    private registryPackageInfraHandler;
     /**
      * Handler for the registryGenerate command
      */

package/dist/index.js

@@ -16069,6 +16069,42 @@ var PLUGIN_COMMANDS = {
         type: "boolean"
       }
     }
+  },
+  registryDeployInfra: {
+    usage: "Deploy the module registry internal infrastructure stack (DynamoDB, EventBridge, SQS, Lambda)",
+    lifecycleEvents: ["deploy"],
+    options: {
+      module: {
+        usage: "Scope composer plugin to a single module during init (avoids loading all modules)",
+        shortcut: "m",
+        required: false,
+        type: "string"
+      },
+      force: {
+        usage: "Force deploy even if internalInfrastructure.enabled is false",
+        shortcut: "f",
+        required: false,
+        type: "boolean"
+      }
+    }
+  },
+  registryPackageInfra: {
+    usage: "Validate and package the module registry internal infrastructure",
+    lifecycleEvents: ["package"],
+    options: {
+      module: {
+        usage: "Scope composer plugin to a single module during init",
+        shortcut: "m",
+        required: false,
+        type: "string"
+      },
+      verbose: {
+        usage: "Show detailed validation information",
+        shortcut: "v",
+        required: false,
+        type: "boolean"
+      }
+    }
   }
 };
 var PLUGIN_HOOKS = {
@@ -16076,7 +16112,9 @@ var PLUGIN_HOOKS = {
   "before:package:initialize": "processModuleRegistryWithVariableResolution",
   "after:aws:deploy:deploy:updateStack": "ensureTableAndUpdateData",
   "registryGenerate:generate": "registryGenerateHandler",
-  "registryGeneratePackage:create": "generateServicePackageCommand"
+  "registryGeneratePackage:create": "generateServicePackageCommand",
+  "registryDeployInfra:deploy": "registryDeployInfraHandler",
+  "registryPackageInfra:package": "registryPackageInfraHandler"
 };
 
 // src/core/config.ts
@@ -17812,8 +17850,27 @@ async function deployInternalInfrastructure(config, logger) {
 }
 async function runServerlessDeploy(cwd, params, logger) {
   const { execa: execa2 } = await Promise.resolve().then(() => (init_execa(), execa_exports));
-  const serverlessBin = import_path6.default.join(cwd, "../../node_modules", ".bin", "serverless");
-  const args = [
+  const candidates = [
+    import_path6.default.join(cwd, "../../node_modules", ".bin", "serverless"),
+    // module-registry's own node_modules
+    import_path6.default.join(cwd, "../../../../node_modules", ".bin", "serverless"),
+    // project root node_modules
+    "npx"
+    // fallback to npx
+  ];
+  let serverlessBin = "npx";
+  for (const candidate of candidates) {
+    try {
+      const fs7 = await import("fs");
+      if (candidate !== "npx" && fs7.existsSync(candidate)) {
+        serverlessBin = candidate;
+        break;
+      }
+    } catch {
+    }
+  }
+  const isNpx = serverlessBin === "npx";
+  const slsArgs = [
     "deploy",
     "--stage",
     params.stage,
@@ -17826,10 +17883,12 @@ async function runServerlessDeploy(cwd, params, logger) {
     "--param",
     `tableName=${params.tableName}`,
     "--param",
-    `policyPrefix=${params.policyPrefix}`,
+    `policyPrefix=${params.policyPrefix || "none"}`,
     "--param",
-    `accountId=${params.accountId}`
+    `accountId=${params.accountId || "auto"}`
   ];
+  const args = isNpx ? ["serverless@4", ...slsArgs] : slsArgs;
+  logger.info(`   Using: ${serverlessBin}${isNpx ? " serverless@4" : ""}`);
   try {
     const result = await execa2(serverlessBin, args, {
       cwd,
@@ -19590,6 +19649,92 @@ var ServerlessModuleRegistryPlugin = class {
       throw new Error(`Infrastructure deployment failed: ${errorMessage}`);
     }
   }
+  /**
+   * Standalone command handler: deploy module registry infrastructure
+   * Bypasses the `enabled: false` check — deploys the DynamoDB table, EventBridge bus, SQS, and Lambda processors.
+   * Usage: `npx serverless@4 registryDeployInfra --stage dev --region sa-east-1`
+   */
+  async registryDeployInfraHandler() {
+    var _a4;
+    this.pluginLogger.trackHookCall("registryDeployInfra:deploy");
+    try {
+      this.logger.info("\u{1F680} Force-deploying Module Registry internal infrastructure...");
+      const service = ((_a4 = this.serverless.service.initialServerlessConfig) == null ? void 0 : _a4.service) || this.serverless.service.service;
+      const stage = this.serverless.service.provider.stage || "dev";
+      const region = this.serverless.service.provider.region || "us-east-1";
+      const accountId = await this.getAwsAccountId();
+      const prefix = `${service}-${stage}`;
+      const tableName = `${prefix}-module-registry`;
+      const policyPrefix = prefix;
+      const infraStackName = `${prefix}-module-registry`;
+      this.logger.info(`   Service: ${service}`);
+      this.logger.info(`   Stack: ${infraStackName}`);
+      this.logger.info(`   Stage: ${stage}`);
+      this.logger.info(`   Region: ${region}`);
+      this.logger.info(`   Table: ${tableName}`);
+      this.logger.info(`   Account: ${accountId || "(auto-detect)"}`);
+      const updatedInfraConfig = {
+        enabled: true,
+        stackName: infraStackName,
+        stage,
+        region,
+        tableName,
+        tableArn: `arn:aws:dynamodb:${region}:${accountId}:table/${tableName}`
+      };
+      this.configManager._config.internalInfrastructure = updatedInfraConfig;
+      this.configManager._config.tableName = tableName;
+      this.configManager._config.policyPrefix = policyPrefix;
+      if (accountId) {
+        process.env.AWS_ACCOUNT_ID = accountId;
+      }
+      const metadata = await deployInternalInfrastructure(this.configManager.config, this.logger);
+      this.logger.info("\u2705 Module Registry infrastructure deployed successfully");
+      this.logger.info(`   Stack: ${metadata.stackName}`);
+      this.logger.info(`   Stream ARN: ${metadata.streamArn}`);
+      this.logger.info(`   Queue URL: ${metadata.queueUrl}`);
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      this.logger.error(`\u274C Module Registry infrastructure deployment failed: ${errorMessage}`);
+      throw new Error(`Module Registry infrastructure deployment failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Standalone command handler: validate/package module registry infrastructure
+   * Validates configuration and checks that internal-infrastructure directory exists.
+   * Usage: `npx serverless@4 registryPackageInfra --stage dev --region sa-east-1`
+   */
+  async registryPackageInfraHandler() {
+    var _a4;
+    this.pluginLogger.trackHookCall("registryPackageInfra:package");
+    try {
+      this.logger.info("\u{1F4E6} Validating Module Registry infrastructure configuration...");
+      const config = this.configManager.config;
+      const serviceName = this.serverless.service.service;
+      const stage = this.serverless.service.provider.stage || "dev";
+      const region = config.region || this.serverless.service.provider.region || "us-east-1";
+      const tableName = config.tableName;
+      const infraStackName = ((_a4 = config.internalInfrastructure) == null ? void 0 : _a4.stackName) || `${serviceName}-${stage}-module-registry`;
+      this.logger.info(`   Service: ${serviceName}`);
+      this.logger.info(`   Stack: ${infraStackName}`);
+      this.logger.info(`   Stage: ${stage}`);
+      this.logger.info(`   Region: ${region}`);
+      this.logger.info(`   Table: ${tableName}`);
+      const infraDir = import_path7.default.join(__dirname, "..", "src", "internal-infrastructure");
+      if (!import_fs7.default.existsSync(infraDir)) {
+        throw new Error(`Internal infrastructure directory not found at: ${infraDir}. Ensure src/internal-infrastructure/ is included in the plugin package.`);
+      }
+      const slsYml = import_path7.default.join(infraDir, "serverless.yml");
+      if (!import_fs7.default.existsSync(slsYml)) {
+        throw new Error(`serverless.yml not found at: ${slsYml}`);
+      }
+      this.logger.info(`   Infrastructure dir: ${infraDir}`);
+      this.logger.info("\u2705 Infrastructure configuration validated \u2014 ready for deploy");
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      this.logger.error(`\u274C Infrastructure validation failed: ${errorMessage}`);
+      throw error;
+    }
+  }
   /**
    * Handler for the registryGenerate command
    */