wip

Author: rickary

flagsmith-jira-app/src/backend/flagsmith.ts

@@ -17,7 +17,7 @@ type PaginatedModels<TModel extends Model> = {
 
 export type Organisation = Model;
 export type Project = Model;
-export type Environment = Model & { api_key: string };
+export type Environment = Model & { api_key: string; project: number };
 
 export type Feature = Model & {
   id: number | string;
@@ -27,6 +27,8 @@ export type Feature = Model & {
   multivariate_options: unknown[];
   num_segment_overrides: number | null;
   num_identity_overrides: number | null;
+  project: number;
+  projectName: string;
 };
 
 export type EnvironmentFeatureState = Model & {
@@ -171,6 +173,8 @@ export const readFeatures: ReadFeatures = async ({ projectIds, environmentId })
   }
 
   const allFeatures: Feature[] = [];
+  const organisationId = await readOrganisationId();
+  const projects = await readProjects({ organisationId });
 
   for (const projectId of projectIds) {
     const params = new URLSearchParams({ is_archived: "false" });
@@ -180,7 +184,19 @@ export const readFeatures: ReadFeatures = async ({ projectIds, environmentId })
     try {
       const data = (await flagsmithApi(apiKey, path)) as PaginatedModels<Feature>;
       const results = await unpaginate(apiKey, data);
-      allFeatures.push(...results);
+
+      const project = projects.find((p) => String(p.id) === String(projectId));
+
+      if (!project) {
+        throw new ApiError(`Flagsmith project ${projectId} not found`, 404);
+      }
+
+      const enrichedFeatures = results.map((feature) => ({
+        ...feature,
+        projectName: project.name,
+      }));
+
+      allFeatures.push(...enrichedFeatures);
     } catch (error) {
       // If a specific project has no features, we can log it but continue with others
       if (error instanceof ApiError && error.code === 404) {
@@ -198,19 +214,6 @@ export const readFeatures: ReadFeatures = async ({ projectIds, environmentId })
   return allFeatures;
 };
 
-// export const readFeatures: ReadFeatures = async ({ projectIds, environmentId }) => {
-//   const apiKey = await readApiKey();
-//   checkApiKey(apiKey);
-//   if (!projectIds) throw new ApiError("Flagsmith project not connected", 400);
-//   const params = new URLSearchParams({ is_archived: "false" });
-//   if (environmentId) params.set("environment", environmentId);
-//   const path = route`/projects/${projectId}/features/?${params}`;
-//   const data = (await flagsmithApi(apiKey, path)) as PaginatedModels<Feature>;
-//   const results = await unpaginate(apiKey, data);
-//   if (results.length === 0) throw new ApiError("Flagsmith project has no features", 404);
-//   return results;
-// };
-
 export type ReadEnvironmentFeatureState = (args: {
   envApiKey: string;
   featureName: string;
@@ -224,6 +227,7 @@ export const readEnvironmentFeatureState: ReadEnvironmentFeatureState = async ({
   const apiKey = await readApiKey();
   checkApiKey(apiKey);
   if (!envApiKey) throw new ApiError("Flagsmith environment not connected", 400);
+
   const path = route`/environments/${envApiKey}/featurestates/?feature_name=${featureName}`;
   const data = (await flagsmithApi(apiKey, path)) as PaginatedModels<EnvironmentFeatureState>;
   const results = await unpaginate(apiKey, data);

flagsmith-jira-app/src/frontend/components/IssueFeatureTables.tsx

@@ -151,29 +151,47 @@ const IssueFeatureTable = ({
   const projectUrl = `${FLAGSMITH_APP}/project/${projectIds[0]}`; // TODO
 
   /** Read feature state for each environment */
-  const readFeatureState = useCallback(
-    async (): Promise<FeatureState> => ({
+  const readFeatureState = useCallback(async (): Promise<FeatureState> => {
+    const featureProjectId = environmentFeatures[0]?.project;
+
+    const environmentFeatureStates = await Promise.all(
+      environments
+        .filter((env) => String(env.project) === String(featureProjectId))
+        .map(async (environment) => {
+          return {
+            ...(await readEnvironmentFeatureState({
+              envApiKey: String(environment.api_key),
+              featureName,
+            })),
+            name: environment.name,
+            api_key: String(environment.api_key),
+          };
+        }),
+    );
+
+    return {
       featureId,
-      environments: await Promise.all(
-        environments.map(async (environment) => ({
-          ...(await readEnvironmentFeatureState({
-            envApiKey: String(environment.api_key),
-            featureName,
-          })),
-          name: environment.name,
-          api_key: String(environment.api_key),
-        })),
-      ),
+      environments: environmentFeatureStates,
       counts: environmentFeatures.map((feature) => ({
         variations: feature.multivariate_options.length,
         segments: feature.num_segment_overrides ?? 0,
         identities: feature.num_identity_overrides ?? 0,
       })),
-    }),
-    [environments, environmentFeatures],
-  );
+    };
+  }, [environments, environmentFeatures]);
+
   const [state] = usePromise(
-    async () => (error === undefined ? readFeatureState() : undefined),
+    async () => {
+      if (error === undefined) {
+        try {
+          return await readFeatureState();
+        } catch (err) {
+          console.error("[ERROR] Failed to read feature state:", err);
+          throw err;
+        }
+      }
+      return undefined;
+    },
     [error, readFeatureState],
     setError,
   );
@@ -227,17 +245,36 @@ const IssueFeatureTables = ({
   return (
     <Fragment>
       {issueFeatureIds.map((featureId) => {
+        console.log("[DEBUG] Processing featureId:", featureId);
+
         const baseFeature = features.find((f) => String(f.id) === featureId);
         if (!baseFeature) {
+          console.warn("[WARN] baseFeature not found for featureId:", featureId);
           return null;
         }
 
-        const envFeaturesForThisFeature = environmentsFeatures
-          .map((envFeatures) => {
-            const matchingFeature = envFeatures.find((f) => String(f.id) === featureId);
-            return matchingFeature;
-          })
-          .filter(Boolean) as Feature[];
+        const envFeaturesForThisFeature: Feature[] = [];
+        const matchingEnvironments: Environment[] = [];
+
+        environmentsFeatures.forEach((envFeatures, index) => {
+          const matchingFeature = envFeatures.find((f) => String(f.id) === featureId);
+          const environment = environments[index];
+          if (matchingFeature && environment !== undefined) {
+            envFeaturesForThisFeature.push(matchingFeature);
+            matchingEnvironments.push(environment);
+          }
+        });
+
+        console.log(
+          `[DEBUG] FeatureId: ${featureId} — envFeaturesForThisFeature.length: ${envFeaturesForThisFeature.length}, matchingEnvironments.length: ${matchingEnvironments.length}`,
+        );
+
+        if (envFeaturesForThisFeature.length === 0 || matchingEnvironments.length === 0) {
+          console.warn(
+            `[WARN] Skipping featureId ${featureId} — no matching features or environments`,
+          );
+          return null;
+        }
 
         return (
           <Fragment key={featureId}>
@@ -252,7 +289,7 @@ const IssueFeatureTables = ({
             </Box>
             <IssueFeatureTable
               projectIds={projectIds}
-              environments={environments}
+              environments={matchingEnvironments}
               environmentFeatures={envFeaturesForThisFeature}
             />
           </Fragment>

flagsmith-jira-app/src/frontend/components/IssueFeaturesForm.tsx

@@ -27,15 +27,32 @@ const IssueFeaturesForm = ({
   }, [props.issueFeatureIds]);
 
   const featureInputId = useId();
-  const featureOptions = useMemo(
-    () =>
-      features.map((each) => ({
-        label: each.name, // might need to change this to localise for a project, or include description?
-        value: String(each.id),
-      })),
-    [features],
-  );
-  const featureValue = featureOptions.filter((option) => featureIds.includes(option.value)) ?? null;
+  const featureOptions = useMemo(() => {
+    const grouped = features.reduce(
+      (acc, feature) => {
+        const projectGroup = acc.find((group) => group.label === feature.projectName);
+        const option = {
+          label: feature.name,
+          value: String(feature.id),
+        };
+        if (projectGroup) {
+          projectGroup.options.push(option);
+        } else {
+          acc.push({
+            label: feature.projectName,
+            options: [option],
+          });
+        }
+        return acc;
+      },
+      [] as { label: string; options: { label: string; value: string }[] }[],
+    );
+    return grouped;
+  }, [features]);
+  const featureValue =
+    featureOptions
+      .flatMap((group) => group.options)
+      .filter((option) => featureIds.includes(option.value)) ?? null;
 
   const onFeatureChange = async (options: { value: string }[]) => {
     const featureIds = options.map((option) => option.value);

flagsmith-jira-app/src/frontend/jira.ts

@@ -86,7 +86,22 @@ const FEATURE_IDS = "flagsmith.features";
 export const readProjectIds = async (extension: ExtensionData): Promise<string[]> => {
   const entityType = "project";
   const entityId = String(extension[entityType].id);
-  return (await getEntityProperty(entityType, entityId, PROJECT_IDS)) ?? [];
+  const stored = await getEntityProperty(entityType, entityId, PROJECT_IDS);
+
+  if (!stored) {
+    return [];
+  }
+
+  if (typeof stored === "string") {
+    return [stored]; // Wrap single string in array
+  }
+
+  if (Array.isArray(stored)) {
+    return stored; // Already an array, perfect
+  }
+
+  // Optional: runtime safeguard
+  throw new Error(`Unexpected type for projectIds: ${typeof stored}`);
 };
 
 /** Write Flagsmith Project ID stored on Jira Project */
@@ -96,7 +111,7 @@ export const writeProjectIds = async (
 ): Promise<void> => {
   const entityType = "project";
   const entityId = String(extension[entityType].id);
-  if (projectIds) {
+  if (projectIds && projectIds.length > 0) {
     return await setEntityProperty(entityType, entityId, PROJECT_IDS, projectIds);
   } else {
     return await deleteEntityProperty(entityType, entityId, PROJECT_IDS);