fern-api 0.30.8-rc5 → 0.30.8-rc6

package/bundle.cjs

@@ -349832,6 +349832,12 @@ var init_WebhookGroupId = __esm({
   }
 });
 
+// pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/api/resources/commons/types/WebhookId.js
+var init_WebhookId = __esm({
+  "pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/api/resources/commons/types/WebhookId.js"() {
+  }
+});
+
 // pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/api/resources/commons/types/WebSocketChannelId.js
 var init_WebSocketChannelId = __esm({
   "pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/api/resources/commons/types/WebSocketChannelId.js"() {
@@ -349905,6 +349911,7 @@ var init_types3 = __esm({
     init_TypeId();
     init_ErrorId();
     init_WebhookGroupId();
+    init_WebhookId();
     init_WebSocketChannelId();
     init_FeatureId();
     init_Declaration();
@@ -354729,6 +354736,15 @@ var init_WebhookGroupId2 = __esm({
   }
 });
 
+// pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/serialization/resources/commons/types/WebhookId.js
+var WebhookId2;
+var init_WebhookId2 = __esm({
+  "pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/serialization/resources/commons/types/WebhookId.js"() {
+    init_core2();
+    WebhookId2 = schemas_exports4.string();
+  }
+});
+
 // pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/serialization/resources/commons/types/WebSocketChannelId.js
 var WebSocketChannelId;
 var init_WebSocketChannelId2 = __esm({
@@ -354808,6 +354824,7 @@ var init_types15 = __esm({
     init_TypeId2();
     init_ErrorId2();
     init_WebhookGroupId2();
+    init_WebhookId2();
     init_WebSocketChannelId2();
     init_FeatureId2();
     init_Declaration2();
@@ -354837,6 +354854,7 @@ __export(commons_exports12, {
   TypeId: () => TypeId,
   WebSocketChannelId: () => WebSocketChannelId,
   WebhookGroupId: () => WebhookGroupId,
+  WebhookId: () => WebhookId2,
   WithDocs: () => WithDocs,
   WithJsonExample: () => WithJsonExample
 });
@@ -357458,6 +357476,7 @@ var init_Webhook2 = __esm({
   "pnp:/home/circleci/project/packages/ir-sdk/lib/sdk/serialization/resources/webhooks/types/Webhook.js"() {
     init_core2();
     Webhook = schemas_exports4.objectWithoutOptionalProperties({
+      id: schemas_exports4.lazy(async () => (await Promise.resolve().then(() => (init_serialization2(), serialization_exports2))).WebhookId).optional(),
       name: schemas_exports4.lazyObject(async () => (await Promise.resolve().then(() => (init_serialization2(), serialization_exports2))).WebhookName),
       displayName: schemas_exports4.string().optional(),
       method: schemas_exports4.lazy(async () => (await Promise.resolve().then(() => (init_serialization2(), serialization_exports2))).WebhookHttpMethod),
@@ -358023,6 +358042,7 @@ __export(serialization_exports2, {
   WebhookGroup: () => WebhookGroup,
   WebhookGroupId: () => WebhookGroupId,
   WebhookHttpMethod: () => WebhookHttpMethod4,
+  WebhookId: () => WebhookId2,
   WebhookName: () => WebhookName,
   WebhookPayload: () => WebhookPayload2,
   WebhookPayloadReference: () => WebhookPayloadReference,
@@ -1054368,7 +1054388,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "0.30.8-rc5",
+          version: "0.30.8-rc6",
           usingAccessToken: true
         }
       });
@@ -1054430,7 +1054450,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "0.30.8-rc5",
+        version: "0.30.8-rc6",
         ...event,
         ...event.properties
       }
@@ -1080373,10 +1080393,10 @@ var CliContext = class {
     return "fern-api";
   }
   getPackageVersion() {
-    if ("0.30.8-rc5" == null) {
+    if ("0.30.8-rc6" == null) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "0.30.8-rc5";
+    return "0.30.8-rc6";
   }
   getCliName() {
     if ("fern" == null) {
@@ -1081205,6 +1081225,10 @@ var IdGenerator = {
     const joinedFernFilePath = stringifyFernFilepath(fernFilepath);
     return `webhooks_${joinedFernFilePath}`;
   },
+  generateWebhookId: (fernFilepath, webhookId) => {
+    const joinedFernFilePath = stringifyFernFilepath(fernFilepath);
+    return `webhooks_${joinedFernFilePath}.${webhookId}`;
+  },
   generateWebSocketChannelId: (fernFilepath) => {
     const joinedFernFilePath = stringifyFernFilepath(fernFilepath);
     return `channel_${joinedFernFilePath}`;
@@ -1084896,6 +1084920,7 @@ async function convertWebhookGroup({ webhooks, file, typeResolver, exampleResolv
   const webhookGroup = [];
   for (const [webhookId, webhook] of Object.entries(webhooks)) {
     webhookGroup.push({
+      id: IdGenerator.generateWebhookId(file.fernFilepath, webhookId),
       availability: convertAvailability2(webhook.availability),
       displayName: webhook["display-name"],
       docs: webhook.docs,
@@ -1085787,13 +1085812,17 @@ var FilteredIrImpl = class {
   services = /* @__PURE__ */ new Set();
   endpoints = /* @__PURE__ */ new Set();
   requestProperties;
+  webhooks = /* @__PURE__ */ new Set();
+  webhookPayloadProperties;
   subpackages = /* @__PURE__ */ new Set();
-  constructor({ types: types3, errors, services, endpoints, subpackages, requestProperties, properties }) {
+  constructor({ types: types3, errors, services, endpoints, webhooks, subpackages, requestProperties, webhookPayloadProperties, properties }) {
     this.types = types3;
     this.properties = properties;
     this.errors = errors;
     this.services = services;
     this.endpoints = endpoints;
+    this.webhooks = webhooks;
+    this.webhookPayloadProperties = webhookPayloadProperties;
     this.subpackages = subpackages;
     this.requestProperties = requestProperties;
   }
@@ -1085841,6 +1085870,19 @@ var FilteredIrImpl = class {
   hasSubpackage(subpackageId) {
     return this.subpackages.has(subpackageId);
   }
+  hasWebhook(webhook) {
+    if (webhook.id) {
+      return this.webhooks.has(webhook.id);
+    }
+    return true;
+  }
+  hasWebhookPayloadProperty(webhookId, property5) {
+    const properties = this.webhookPayloadProperties[webhookId];
+    if (properties == null) {
+      return true;
+    }
+    return properties.has(property5);
+  }
 };
 
 // pnp:/home/circleci/project/packages/cli/generation/ir-generator/lib/filtered-ir/IrGraph.js
@@ -1085848,13 +1085890,16 @@ var IrGraph = class {
   types = {};
   properties = {};
   requestProperties = {};
+  webhookProperties = {};
   errors = {};
   endpoints = {};
+  webhooks = {};
   audiences;
   typesReferencedByService = {};
   typesNeededForAudience = /* @__PURE__ */ new Set();
   servicesNeededForAudience = /* @__PURE__ */ new Set();
   endpointsNeededForAudience = /* @__PURE__ */ new Set();
+  webhooksNeededForAudience = /* @__PURE__ */ new Set();
   subpackagesNeededForAudience = /* @__PURE__ */ new Set();
   constructor(audiences) {
     this.audiences = audiencesFromConfig(audiences);
@@ -1086015,6 +1086060,56 @@ var IrGraph = class {
       this.addSubpackages(declaredServiceName.fernFilepath);
     }
   }
+  addWebhook(file, webhook, rawWebhook) {
+    const webhookId = webhook.id;
+    if (webhookId == null) {
+      return;
+    }
+    const referencedTypes = /* @__PURE__ */ new Set();
+    const referencedSubpackages = /* @__PURE__ */ new Set();
+    if (webhook.payload != null) {
+      WebhookPayload._visit(webhook.payload, {
+        inlinedPayload: (inlinedPayload) => {
+          for (const extension3 of inlinedPayload.extends) {
+            populateReferencesFromTypeName(extension3, referencedTypes, referencedSubpackages);
+          }
+          for (const property5 of inlinedPayload.properties) {
+            populateReferencesFromTypeReference(property5.valueType, referencedTypes, referencedSubpackages);
+          }
+          if ((rawWebhook == null ? void 0 : rawWebhook.payload) != null && typeof rawWebhook.payload === "object" && !isReferencedWebhookPayloadSchema2(rawWebhook.payload)) {
+            const propertiesByAudience = getPropertiesForAudience(rawWebhook.payload.properties ?? {});
+            this.webhookProperties[webhookId] = {
+              webhookId,
+              propertiesByAudience
+            };
+          }
+        },
+        reference: ({ payloadType }) => {
+          populateReferencesFromTypeReference(payloadType, referencedTypes, referencedSubpackages);
+        },
+        _other: () => {
+          var _a5;
+          throw new Error("Unknown WebhookPayload: " + ((_a5 = webhook.payload) == null ? void 0 : _a5.type));
+        }
+      });
+    }
+    referencedSubpackages.add(file.fernFilepath);
+    this.webhooks[webhookId] = {
+      webhookId,
+      referencedTypes,
+      referencedSubpackages
+    };
+  }
+  markWebhookForAudiences(file, webhook, audiences) {
+    const webhookId = webhook.id;
+    if (webhookId == null) {
+      return;
+    }
+    if (this.hasAudience(audiences)) {
+      this.webhooksNeededForAudience.add(webhookId);
+      this.addSubpackages(file.fernFilepath);
+    }
+  }
   build() {
     const typeIds = /* @__PURE__ */ new Set();
     const errorIds = /* @__PURE__ */ new Set();
@@ -1086031,8 +1086126,13 @@ var IrGraph = class {
       this.addReferencedTypes(typeIds, endpointNode.referencedTypes);
     }
     this.addReferencedTypes(typeIds, this.typesNeededForAudience);
+    for (const webhookId of this.webhooksNeededForAudience.keys()) {
+      const webhookNode = this.getWebhookNode(webhookId);
+      this.addReferencedTypes(typeIds, webhookNode.referencedTypes);
+    }
     const properties = {};
     const requestProperties = {};
+    const webhookPayloadProperties = {};
     if (this.audiences.type === "filtered") {
       for (const [typeId, typePropertiesNode] of Object.entries(this.properties)) {
         if (!typeIds.has(typeId)) {
@@ -1086068,6 +1086168,23 @@ var IrGraph = class {
           requestProperties[endpointId] = propertiesForEndpoint;
         }
       }
+      for (const [webhookId, webhookPaylodPropertiesNode] of Object.entries(this.webhookProperties)) {
+        if (!this.webhooksNeededForAudience.has(webhookId)) {
+          continue;
+        }
+        const propertiesForWebhook = /* @__PURE__ */ new Set();
+        for (const audience of this.audiences.audiences) {
+          const propertiesForAudience = webhookPaylodPropertiesNode.propertiesByAudience[audience];
+          if (propertiesForAudience != null) {
+            propertiesForAudience.forEach((property5) => {
+              propertiesForWebhook.add(property5);
+            });
+          }
+        }
+        if (propertiesForWebhook.size > 0) {
+          requestProperties[webhookId] = propertiesForWebhook;
+        }
+      }
     }
     return new FilteredIrImpl({
       types: typeIds,
@@ -1086076,6 +1086193,8 @@ var IrGraph = class {
       requestProperties,
       services: this.servicesNeededForAudience,
       endpoints: this.endpointsNeededForAudience,
+      webhooks: this.webhooksNeededForAudience,
+      webhookPayloadProperties,
       subpackages: this.subpackagesNeededForAudience
     });
   }
@@ -1086136,6 +1086255,13 @@ var IrGraph = class {
     }
     return endpointNode;
   }
+  getWebhookNode(webhookId) {
+    const webhookNode = this.webhooks[webhookId];
+    if (webhookNode == null) {
+      throw new Error(`Failed to find webhook node with id ${webhookId}`);
+    }
+    return webhookNode;
+  }
   hasNoAudiences() {
     return this.audiences.type === "none";
   }
@@ -1087462,6 +1087588,19 @@ async function generateIntermediateRepresentation({ workspace, generationLanguag
           exampleResolver,
           workspace
         });
+        const webhooksByOriginalName = {};
+        for (const convertedWebhook of convertedWebhookGroup) {
+          webhooksByOriginalName[convertedWebhook.name.originalName] = convertedWebhook;
+        }
+        Object.entries(webhooks).forEach(([key2, webhook]) => {
+          const irWebhook = webhooksByOriginalName[key2];
+          if (irWebhook != null) {
+            irGraph.addWebhook(file, irWebhook, webhook);
+            if (webhook.audiences != null) {
+              irGraph.markWebhookForAudiences(file, irWebhook, webhook.audiences);
+            }
+          }
+        });
         intermediateRepresentation.webhookGroups[webhookGroupId] = convertedWebhookGroup;
         packageTreeGenerator.addWebhookGroup(webhookGroupId, file.fernFilepath);
       },
@@ -1087611,6 +1087750,21 @@ function filterIntermediateRepresentationForAudiences(intermediateRepresentation
     }
     return [typeId, typeDeclaration];
   }));
+  const filteredWebhookGroups = Object.fromEntries(Object.entries(intermediateRepresentation.webhookGroups).map(([webhookGroupId, webhookGroup]) => {
+    const filteredWebhooks = webhookGroup.filter((webhook) => filteredIr.hasWebhook(webhook)).map((webhook) => {
+      const webhookId = webhook.id;
+      if (webhook.payload.type === "inlinedPayload" && webhookId != null) {
+        webhook.payload = {
+          ...webhook.payload,
+          properties: webhook.payload.properties.filter((property5) => {
+            return filteredIr.hasWebhookPayloadProperty(webhookId, property5.name.wireValue);
+          })
+        };
+      }
+      return webhook;
+    });
+    return [webhookGroupId, filteredWebhooks];
+  }));
   return {
     ...intermediateRepresentation,
     types: filteredTypesAndProperties,
@@ -1087645,6 +1087799,7 @@ function filterIntermediateRepresentationForAudiences(intermediateRepresentation
         return httpEndpoint;
       })
     })),
+    webhookGroups: filteredWebhookGroups,
     serviceTypeReferenceInfo: filterServiceTypeReferenceInfoForAudiences(intermediateRepresentation.serviceTypeReferenceInfo, filteredIr)
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fern-api",
-  "version": "0.30.8-rc5",
+  "version": "0.30.8-rc6",
   "repository": {
     "type": "git",
     "url": "https://github.com/fern-api/fern.git",