Clean up manifest parsing

Author: wandamora

src/deploy/functions/runtimes/discovery/v1alpha1.spec.ts

@@ -1102,4 +1102,136 @@ describe("buildFromV1Alpha", () => {
       expect(parsed).to.deep.equal(expected);
     });
   });
+
+  describe("lifecycleHooks", () => {
+    it("copies valid task lifecycle hooks", () => {
+      const yaml: v1alpha1.WireManifest = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          afterInstall: {
+            task: {
+              function: "myTaskFunc",
+              body: { key: "value" },
+            },
+          },
+        },
+      };
+
+      const parsed = v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME);
+      const expected: build.Build = build.empty();
+      expected.lifecycleHooks = {
+        afterInstall: {
+          task: {
+            function: "myTaskFunc",
+            body: { key: "value" },
+          },
+        },
+      };
+      expect(parsed).to.deep.equal(expected);
+    });
+
+    it("copies valid callable lifecycle hooks", () => {
+      const yaml: v1alpha1.WireManifest = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          afterUpdate: {
+            callable: {
+              function: "myCallableFunc",
+            },
+          },
+        },
+      };
+
+      const parsed = v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME);
+      const expected: build.Build = build.empty();
+      expected.lifecycleHooks = {
+        afterUpdate: {
+          callable: {
+            function: "myCallableFunc",
+          },
+        },
+      };
+      expect(parsed).to.deep.equal(expected);
+    });
+
+    it("copies valid http lifecycle hooks", () => {
+      const yaml: v1alpha1.WireManifest = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          afterInstall: {
+            http: {
+              url: "https://example.com/hook",
+              body: "some-body",
+            },
+          },
+        },
+      };
+
+      const parsed = v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME);
+      const expected: build.Build = build.empty();
+      expected.lifecycleHooks = {
+        afterInstall: {
+          http: {
+            url: "https://example.com/hook",
+            body: "some-body",
+          },
+        },
+      };
+      expect(parsed).to.deep.equal(expected);
+    });
+
+    it("throws on invalid event type", () => {
+      const yaml = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          invalidHookName: {
+            task: {
+              function: "myTaskFunc",
+            },
+          },
+        },
+      };
+
+      expect(() => v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME)).to.throw(
+        FirebaseError,
+        /Invalid eventType "invalidHookName" for lifecycle hook/,
+      );
+    });
+
+    it("throws when target function is missing in task hook", () => {
+      const yaml = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          afterInstall: {
+            task: {},
+          },
+        },
+      };
+
+      expect(() => v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME)).to.throw(
+        FirebaseError,
+        /Invalid target "" for lifecycle hook "afterInstall"/,
+      );
+    });
+
+    it("throws when action is missing", () => {
+      const yaml = {
+        specVersion: "v1alpha1",
+        endpoints: {},
+        lifecycleHooks: {
+          afterInstall: {},
+        },
+      };
+
+      expect(() => v1alpha1.buildFromV1Alpha1(yaml, PROJECT, REGION, RUNTIME)).to.throw(
+        FirebaseError,
+        /No action \(task, callable, or http\) specified for lifecycle hook "afterInstall"/,
+      );
+    });
+  });
 });

src/deploy/functions/runtimes/discovery/v1alpha1.ts

@@ -157,54 +157,31 @@ export function buildFromV1Alpha1(
       if (!hook || typeof hook !== "object") {
         throw new FirebaseError(`Invalid lifecycle hook configuration for "${id}".`);
       }
-      const parsedHook: backend.LifecycleHook = {};
 
       if (hook.task) {
         if (typeof hook.task.function !== "string" || !hook.task.function) {
           throw new FirebaseError(
             `Invalid target "${hook.task.function || ""}" for lifecycle hook "${id}"`,
           );
         }
-        parsedHook.task = {
-          function: hook.task.function,
-        };
-        if (hook.task.body !== undefined) {
-          parsedHook.task.body = hook.task.body as Record<string, unknown>;
-        }
       } else if (hook.callable) {
         if (typeof hook.callable.function !== "string" || !hook.callable.function) {
           throw new FirebaseError(
             `Invalid target "${hook.callable.function || ""}" for lifecycle hook "${id}"`,
           );
         }
-        parsedHook.callable = {
-          function: hook.callable.function,
-        };
-        if (hook.callable.body !== undefined) {
-          parsedHook.callable.body = hook.callable.body as Record<string, unknown>;
-        }
       } else if (hook.http) {
         const target = hook.http.url || hook.http.function;
         if (typeof target !== "string" || !target) {
           throw new FirebaseError(`Invalid target "${target || ""}" for lifecycle hook "${id}"`);
         }
-        parsedHook.http = {};
-        if (hook.http.function) {
-          parsedHook.http.function = hook.http.function;
-        }
-        if (hook.http.url) {
-          parsedHook.http.url = hook.http.url;
-        }
-        if (hook.http.body !== undefined) {
-          parsedHook.http.body = hook.http.body;
-        }
       } else {
         throw new FirebaseError(
           `No action (task, callable, or http) specified for lifecycle hook "${id}"`,
         );
       }
 
-      bd.lifecycleHooks[id] = parsedHook;
+      bd.lifecycleHooks[id] = hook as backend.LifecycleHook;
     }
   }
   return bd;