@opencoredev/social-sdk 0.1.1 → 0.2.0

package/dist/platforms/linkedin.js

@@ -17,6 +17,7 @@ export function linkedin(options) {
     }
     const http = createHttp(options.fetch ? { fetch: options.fetch } : {});
     const now = () => (options.clock?.() ?? new Date()).toISOString();
+    const escapeCommentary = (text) => text.replace(/[|{}@()[\]<>#\\*_~]/g, "\\$&");
     const authorize = (ref, context) => {
         if (ref.backend !== context.backendInstance ||
             ref.platform !== "linkedin" ||
@@ -27,7 +28,7 @@ export function linkedin(options) {
                 message: "Reference does not belong to this LinkedIn author authorization.",
             });
     };
-    async function request(path, context, body, selectedHeaders, method = body === undefined ? "GET" : "POST") {
+    async function request(path, context, body, selectedHeaders, method = body === undefined ? "GET" : "POST", extraHeaders) {
         try {
             return await http({
                 timeoutMs: remainingBudget(context),
@@ -37,10 +38,14 @@ export function linkedin(options) {
                     "Content-Type": "application/json",
                     "Linkedin-Version": options.apiVersion,
                     "X-Restli-Protocol-Version": "2.0.0",
+                    ...extraHeaders,
                 },
                 method,
+                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                 ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                 ...(context.signal ? { signal: context.signal } : {}),
+                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                 ...(selectedHeaders ? { responseHeaders: selectedHeaders } : {}),
                 maxAttempts: method === "GET" ? Math.min(5, context.retryBudget.maxAttempts) : 1,
             });
@@ -54,17 +59,27 @@ export function linkedin(options) {
             throw new SocialError({
                 code: ambiguous
                     ? "ambiguous_outcome"
-                    : error.status === 401
-                        ? "reconnect_required"
-                        : error.status === 403
-                            ? "missing_permission"
-                            : error.status === 429
-                                ? "rate_limited"
-                                : "upstream_failure",
+                    : error.kind === "timeout"
+                        ? "timeout"
+                        : error.kind === "cancelled"
+                            ? "cancelled"
+                            : error.status === 401
+                                ? "reconnect_required"
+                                : error.status === 403
+                                    ? "missing_permission"
+                                    : error.status === 404
+                                        ? "not_found"
+                                        : error.status === 429
+                                            ? "rate_limited"
+                                            : "upstream_failure",
                 operation: path,
                 message: error.message,
                 upstreamStatus: error.status,
-                retryDisposition: ambiguous ? { kind: "reconcile-first" } : { kind: "never" },
+                retryDisposition: ambiguous
+                    ? { kind: "reconcile-first" }
+                    : error.status === 429 && error.retryAfterMs !== undefined
+                        ? { kind: "after-delay", delayMs: error.retryAfterMs }
+                        : { kind: "never" },
             });
         }
     }
@@ -116,12 +131,15 @@ export function linkedin(options) {
             url: string(initialized["uploadUrl"]),
             source: {
                 mimeType: media.mimeType,
+                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                 ...(size === undefined ? {} : { size }),
                 open: source.kind === "blob" ? () => source.blob.stream() : source.open,
             },
             allowHost: (host) => host === "www.linkedin.com",
             maxBytes: 20 * 1024 * 1024,
+            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
             ...(options.fetch ? { fetch: options.fetch } : {}),
+            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
             ...(context.signal ? { signal: context.signal } : {}),
         });
         return {
@@ -133,6 +151,208 @@ export function linkedin(options) {
             mediaId,
         };
     }
+    /* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-known-value-widening, anti-slop/no-conditional-empty-object-spread, anti-slop/no-runtime-typeof, anti-slop/require-readable-spacing -- These helpers normalize documented LinkedIn response facets at the transport boundary. */
+    const organizationOnly = (account, context, operation) => {
+        authorize(account, context);
+        if (!account.accountId.startsWith("urn:li:organization:"))
+            throw new SocialError({
+                code: "unsupported_capability",
+                operation,
+                message: "LinkedIn organization analytics require an organization account, not a member account.",
+            });
+    };
+    const statisticsPath = (path, finder, account, interval) => {
+        const params = [`q=${finder}`, `${finder}=${encodeURIComponent(account.accountId)}`];
+        if (interval) {
+            if (interval.start !== undefined &&
+                (!Number.isSafeInteger(interval.start) || interval.start < 0))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.organization.read",
+                    message: "Interval start must be a nonnegative epoch-millisecond integer.",
+                });
+            if (interval.end !== undefined && (!Number.isSafeInteger(interval.end) || interval.end < 0))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.organization.read",
+                    message: "Interval end must be a nonnegative epoch-millisecond integer.",
+                });
+            if (interval.start !== undefined &&
+                interval.end !== undefined &&
+                interval.end <= interval.start)
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.organization.read",
+                    message: "Interval end must be after interval start.",
+                });
+            if (interval.start === undefined)
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.organization.read",
+                    message: "Interval start is required for time-bound organization statistics.",
+                });
+            const rangeParts = [
+                `start:${interval.start}`,
+                ...(interval.end === undefined ? [] : [`end:${interval.end}`]),
+            ];
+            const range = `(timeRange:(${rangeParts.join(",")}),timeGranularityType:${interval.granularity})`;
+            if (!["DAY", "WEEK", "MONTH"].includes(interval.granularity))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.organization.read",
+                    message: "Interval granularity must be DAY, WEEK or MONTH.",
+                });
+            params.push(`timeIntervals=${range}`);
+        }
+        return `${path}?${params.join("&")}`;
+    };
+    const numberMap = (value) => {
+        const row = value === undefined ? {} : object(value);
+        const output = {};
+        for (const [key, item] of Object.entries(row)) {
+            const number = optionalNumber(item);
+            if (number !== undefined)
+                output[key] = number;
+            else if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+                const nestedObject = object(item);
+                const nested = ["pageViews", "uniquePageViews", "clicks", "count"]
+                    .map((name) => optionalNumber(nestedObject[name]))
+                    .find((candidate) => candidate !== undefined);
+                if (nested !== undefined)
+                    output[key] = nested;
+                else {
+                    for (const [nestedKey, nestedValue] of Object.entries(nestedObject)) {
+                        const nestedNumber = optionalNumber(nestedValue);
+                        if (nestedNumber !== undefined)
+                            output[`${key}.${nestedKey}`] = nestedNumber;
+                    }
+                }
+            }
+        }
+        return output;
+    };
+    const followerBreakdowns = (row) => {
+        const dimensions = [
+            ["function", "followerCountsByFunction", "function"],
+            ["seniority", "followerCountsBySeniority", "seniority"],
+            ["industry", "followerCountsByIndustry", "industry"],
+            ["geo", "followerCountsByGeo", "geo"],
+            ["geoCountry", "followerCountsByGeoCountry", "geo"],
+            ["staffCountRange", "followerCountsByStaffCountRange", "staffCountRange"],
+            ["associationType", "followerCountsByAssociationType", "associationType"],
+        ];
+        const output = [];
+        for (const [dimension, field, key] of dimensions) {
+            if (row[field] === undefined)
+                continue;
+            for (const value of array(row[field])) {
+                const item = object(value);
+                const label = optionalString(item[key]);
+                if (!label)
+                    continue;
+                const counts = item["followerCounts"] === undefined ? {} : object(item["followerCounts"]);
+                output.push({
+                    dimension,
+                    value: label,
+                    ...(optionalNumber(counts["organicFollowerCount"]) === undefined
+                        ? {}
+                        : { organicFollowerCount: optionalNumber(counts["organicFollowerCount"]) }),
+                    ...(optionalNumber(counts["paidFollowerCount"]) === undefined
+                        ? {}
+                        : { paidFollowerCount: optionalNumber(counts["paidFollowerCount"]) }),
+                });
+            }
+        }
+        return output;
+    };
+    const parseInterval = (row, requestedGranularity) => {
+        if (row["timeRange"] === undefined)
+            return undefined;
+        const range = object(row["timeRange"]);
+        const start = optionalNumber(range["start"]);
+        const end = optionalNumber(range["end"]);
+        const granularity = requestedGranularity ?? optionalString(row["timeGranularityType"]);
+        if ((granularity !== "DAY" && granularity !== "WEEK" && granularity !== "MONTH") ||
+            (start === undefined && end === undefined))
+            return undefined;
+        return {
+            granularity,
+            ...(start === undefined ? {} : { start }),
+            ...(end === undefined ? {} : { end }),
+        };
+    };
+    const parseFollowerStatistics = (result, requestedGranularity) => array(result["elements"]).map((value) => {
+        const row = object(value);
+        const gains = row["followerGains"] === undefined ? {} : object(row["followerGains"]);
+        return {
+            organization: string(row["organizationalEntity"]),
+            ...(parseInterval(row, requestedGranularity) === undefined
+                ? {}
+                : { interval: parseInterval(row, requestedGranularity) }),
+            ...(optionalNumber(gains["organicFollowerGain"]) === undefined
+                ? {}
+                : { organicFollowerGain: optionalNumber(gains["organicFollowerGain"]) }),
+            ...(optionalNumber(gains["paidFollowerGain"]) === undefined
+                ? {}
+                : { paidFollowerGain: optionalNumber(gains["paidFollowerGain"]) }),
+            breakdowns: followerBreakdowns(row),
+        };
+    });
+    const pageBreakdowns = (row) => {
+        const output = [];
+        for (const [field, dimension, key] of [
+            ["pageStatisticsByFunction", "function", "function"],
+            ["pageStatisticsBySeniority", "seniority", "seniority"],
+            ["pageStatisticsByIndustryV2", "industryV2", "industryV2"],
+            ["pageStatisticsByIndustry", "industry", "industry"],
+            ["pageStatisticsByGeo", "geo", "geo"],
+            ["pageStatisticsByGeoCountry", "geoCountry", "geo"],
+            ["pageStatisticsByStaffCountRange", "staffCountRange", "staffCountRange"],
+        ]) {
+            if (row[field] === undefined)
+                continue;
+            for (const value of array(row[field])) {
+                const item = object(value);
+                const label = optionalString(item[key]);
+                if (!label)
+                    continue;
+                const stats = item["pageStatistics"] === undefined ? {} : object(item["pageStatistics"]);
+                const views = stats["views"] === undefined ? {} : object(stats["views"]);
+                const clicks = stats["clicks"] === undefined ? {} : object(stats["clicks"]);
+                output.push({
+                    dimension,
+                    value: label,
+                    views: numberMap(views),
+                    clicks: numberMap(clicks),
+                });
+            }
+        }
+        return output;
+    };
+    const parsePageStatistics = (result, requestedGranularity) => array(result["elements"]).map((value) => {
+        const row = object(value);
+        const total = row["totalPageStatistics"] === undefined ? {} : object(row["totalPageStatistics"]);
+        return {
+            organization: string(row["organization"]),
+            ...(parseInterval(row, requestedGranularity) === undefined
+                ? {}
+                : { interval: parseInterval(row, requestedGranularity) }),
+            views: numberMap(total["views"]),
+            clicks: numberMap(total["clicks"]),
+            breakdowns: pageBreakdowns(row),
+        };
+    });
+    const parseShareStatistics = (result, requestedGranularity) => array(result["elements"]).map((value) => {
+        const row = object(value);
+        return {
+            organization: string(row["organizationalEntity"]),
+            ...(parseInterval(row, requestedGranularity) === undefined
+                ? {}
+                : { interval: parseInterval(row, requestedGranularity) }),
+            metrics: numberMap(row["totalShareStatistics"]),
+        };
+    });
+    /* oxlint-enable anti-slop/no-unknown-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-known-value-widening, anti-slop/no-conditional-empty-object-spread, anti-slop/no-runtime-typeof */
     return defineAdapter({
         id: "linkedin",
         capabilities: {
@@ -167,25 +387,38 @@ export function linkedin(options) {
                 {
                     platform: "linkedin",
                     operation: "posts.multi-image",
-                    availability: "available",
+                    availability: "not-implemented-by-adapter",
                     formats: ["carousel"],
                 },
                 {
                     platform: "linkedin",
                     operation: "posts.video",
-                    availability: "available",
+                    availability: "not-implemented-by-adapter",
                     formats: ["video"],
                 },
-                { platform: "linkedin", operation: "posts.document", availability: "available" },
+                {
+                    platform: "linkedin",
+                    operation: "posts.document",
+                    availability: "not-implemented-by-adapter",
+                },
                 { platform: "linkedin", operation: "polls.create", availability: "available" },
                 { platform: "linkedin", operation: "reactions.write", availability: "available" },
                 { platform: "linkedin", operation: "reshares.write", availability: "available" },
                 { platform: "linkedin", operation: "posts.update", availability: "available" },
                 { platform: "linkedin", operation: "posts.delete", availability: "available" },
+                {
+                    platform: "linkedin",
+                    operation: "posts.removeFromPlatform",
+                    availability: "available",
+                },
                 {
                     platform: "linkedin",
                     operation: "analytics.organization.read",
-                    availability: "permission-required",
+                    availability: options.auth.author.startsWith("urn:li:organization:")
+                        ? "available"
+                        : "account-ineligible",
+                    requiredScopes: ["rw_organization_admin"],
+                    notes: "Requires the Community Management API product and organization administrator access. Member accounts are not eligible.",
                 },
                 {
                     platform: "linkedin",
@@ -206,6 +439,15 @@ export function linkedin(options) {
                     requiredScopes: ["rw_organization_admin"],
                     notes: "Organization total followers only; authenticated member must administer the organization. No member-profile analytics claimed.",
                 },
+                ...["analytics.followers.read", "analytics.page.read", "analytics.shares.read"].map((operation) => ({
+                    platform: "linkedin",
+                    operation,
+                    availability: options.auth.author.startsWith("urn:li:organization:")
+                        ? "available"
+                        : "account-ineligible",
+                    requiredScopes: ["rw_organization_admin"],
+                    notes: "Community Management API product and organization administrator access are required. Member accounts are not eligible.",
+                })),
                 {
                     platform: "linkedin",
                     operation: "posts.list",
@@ -215,7 +457,7 @@ export function linkedin(options) {
                             ? "r_organization_social"
                             : "r_member_social",
                     ],
-                    notes: "Author feed requires approved read access for the configured author.",
+                    notes: "Author-feed pagination uses the returned offset cursor.",
                 },
                 {
                     platform: "linkedin",
@@ -227,6 +469,9 @@ export function linkedin(options) {
                     platform: "linkedin",
                     operation,
                     availability: "available",
+                    ...(operation === "analytics.read"
+                        ? { requiredScopes: ["r_member_social"] }
+                        : { requiredScopes: ["w_member_social", "r_member_social"] }),
                     notes: "Community Management product permissions and author post read access required. Analytics contains returned social-action counts only.",
                 })),
             ],
@@ -269,14 +514,24 @@ export function linkedin(options) {
                 let content;
                 if (media?.source.kind === "media-ref") {
                     authorize(media.source.ref, context);
-                    const image = object(await request(`/rest/images/${encodeURIComponent(media.source.ref.mediaId)}`, context));
-                    if (image["owner"] !== target.account.accountId)
+                    let image;
+                    try {
+                        // SAFETY: object() validates the upstream response as a JSON object.
+                        image = object(await request(`/rest/images/${encodeURIComponent(media.source.ref.mediaId)}`, context));
+                    }
+                    catch (error) {
+                        if (!(error instanceof SocialError) ||
+                            error.code !== "missing_permission" ||
+                            !options.auth.author.startsWith("urn:li:person:"))
+                            throw error;
+                    }
+                    if (image?.["owner"] !== undefined && image["owner"] !== target.account.accountId)
                         throw new SocialError({
                             code: "unauthorized",
                             operation: "posts.publish",
                             message: "LinkedIn image belongs to a different author.",
                         });
-                    if (image["status"] !== "AVAILABLE")
+                    if (image?.["status"] !== undefined && image["status"] !== "AVAILABLE")
                         throw new SocialError({
                             code: "media_error",
                             operation: "posts.publish",
@@ -285,13 +540,14 @@ export function linkedin(options) {
                     content = {
                         media: {
                             id: media.source.ref.mediaId,
+                            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                             ...(media.altText ? { altText: media.altText } : {}),
                         },
                     };
                 }
                 const result = object(await request("/rest/posts", context, {
                     author: target.account.accountId,
-                    commentary: target.content.text ?? "",
+                    commentary: escapeCommentary(target.content.text ?? ""),
                     visibility: "PUBLIC",
                     distribution: {
                         feedDistribution: "MAIN_FEED",
@@ -300,6 +556,7 @@ export function linkedin(options) {
                     },
                     lifecycleState: "PUBLISHED",
                     isReshareDisabledByAuthor: false,
+                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                     ...(content ? { content } : {}),
                 }, ["x-restli-id"]));
                 const id = optionalString(object(result["headers"])["x-restli-id"]);
@@ -376,11 +633,16 @@ export function linkedin(options) {
                 const hasNext = array(paging["links"] ?? []).some((link) => object(link)["rel"] === "next");
                 return {
                     items,
+                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                     ...(items.length > 0 && (hasNext || (total !== undefined && start + items.length < total))
                         ? { nextCursor: String(start + items.length) }
                         : {}),
                 };
             },
+            async removeFromPlatform(ref, context) {
+                authorize(ref, context);
+                await request(`/rest/posts/${encodeURIComponent(ref.postId)}`, context, undefined, undefined, "DELETE");
+            },
         },
         comments: {
             async list(ref, input, context) {
@@ -410,6 +672,7 @@ export function linkedin(options) {
                 const next = total !== undefined && start + items.length < total
                     ? String(start + items.length)
                     : undefined;
+                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
                 return { items, ...(next === undefined ? {} : { nextCursor: next }) };
             },
             async reply(ref, content, context) {
@@ -420,21 +683,24 @@ export function linkedin(options) {
                         message: "Provide a comment of 1 to 1,250 characters.",
                     });
                 await readCommentablePost({ ...ref, kind: "platform-post" }, context);
-                const match = /^urn:li:comment:\(urn:li:activity:\d+,(\d+)\)$/.exec(ref.commentId);
+                const match = /^urn:li:comment:\(urn:li:activity:(\d+),(\d+)\)$/.exec(ref.commentId);
                 if (!match)
                     throw new SocialError({
                         code: "invalid_input",
                         operation: "comments.write",
                         message: "Use the complete commentUrn returned by LinkedIn comment reads.",
                     });
-                const parent = object(await request(`/rest/socialActions/${encodeURIComponent(ref.postId)}/comments/${match[1]}`, context));
+                const parent = object(await request(`/rest/socialActions/${encodeURIComponent(ref.postId)}/comments/${match[2]}`, context));
                 if (parent["commentUrn"] !== ref.commentId)
                     throw new SocialError({
                         code: "unauthorized",
                         operation: "comments.write",
                         message: "Comment does not belong to the supplied post.",
                     });
-                if (typeof parent["object"] === "string" && parent["object"] !== ref.postId)
+                const parentObject = optionalString(parent["object"]);
+                if (parentObject !== undefined &&
+                    parentObject !== ref.postId &&
+                    parentObject !== `urn:li:activity:${match[1]}`)
                     throw new SocialError({
                         code: "unauthorized",
                         operation: "comments.write",
@@ -525,46 +791,73 @@ export function linkedin(options) {
                     });
                 return publicFields(image, ["id", "owner", "status"]);
             },
-            async registerVideo({ account, byteSize, context }) {
+            async registerVideo({ account, context }) {
                 authorize(account, context);
-                return (await request("/rest/videos?action=initializeUpload", context, {
-                    initializeUploadRequest: { owner: account.accountId, fileSizeBytes: byteSize },
-                }));
+                throw new SocialError({
+                    code: "unsupported_capability",
+                    operation: "posts.video",
+                    message: "LinkedIn video publishing is not implemented by this adapter.",
+                });
             },
-            async createPoll({ account, text, options: pollOptions, context }) {
+            async createPoll({ account, text, options: pollOptions, duration = "THREE_DAYS", context }) {
                 authorize(account, context);
-                return (await request("/rest/posts", context, {
+                const result = object(await request("/rest/posts", context, {
                     author: account.accountId,
-                    commentary: text,
-                    distribution: { feedDistribution: "MAIN_FEED" },
-                    content: { poll: { question: text, options: [...pollOptions] } },
-                }));
+                    commentary: escapeCommentary(text),
+                    visibility: "PUBLIC",
+                    distribution: {
+                        feedDistribution: "MAIN_FEED",
+                        targetEntities: [],
+                        thirdPartyDistributionChannels: [],
+                    },
+                    lifecycleState: "PUBLISHED",
+                    content: {
+                        poll: {
+                            question: text,
+                            options: pollOptions.map((option) => ({ text: option })),
+                            settings: { duration },
+                        },
+                    },
+                }, ["x-restli-id"]));
+                const id = optionalString(object(result["headers"])["x-restli-id"]);
+                // SAFETY: result is validated as a JSON object and id is a JSON string.
+                return (id === undefined ? result : { ...result, id });
             },
             async react({ account, postId, reaction, context }) {
                 authorize(account, context);
-                await request(`/rest/reactions`, context, {
+                await request(`/rest/reactions?actor=${encodeURIComponent(account.accountId)}`, context, {
                     root: postId,
                     reactionType: reaction,
-                    actor: account.accountId,
                 });
             },
             async reshare({ account, postId, context }) {
                 authorize(account, context);
-                return (await request("/rest/posts", context, {
+                const result = object(await request("/rest/posts", context, {
                     author: account.accountId,
-                    resharedPost: postId,
                     commentary: "",
-                }));
+                    visibility: "PUBLIC",
+                    distribution: {
+                        feedDistribution: "MAIN_FEED",
+                        targetEntities: [],
+                        thirdPartyDistributionChannels: [],
+                    },
+                    lifecycleState: "PUBLISHED",
+                    reshareContext: { parent: postId },
+                }, ["x-restli-id"]));
+                const id = optionalString(object(result["headers"])["x-restli-id"]);
+                // SAFETY: result is validated as a JSON object and id is a JSON string.
+                return (id === undefined ? result : { ...result, id });
             },
             async updatePost({ account, postId, body, context }) {
                 authorize(account, context);
-                return (await request(`/rest/posts/${encodeURIComponent(postId)}`, context, body, undefined, "PUT"));
+                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
+                return (await request(`/rest/posts/${encodeURIComponent(postId)}`, context, { patch: { $set: body } }, ["x-restli-id"], "POST", { "X-RestLi-Method": "PARTIAL_UPDATE" }));
             },
             async deletePost({ account, postId, context }) {
                 authorize(account, context);
                 await request(`/rest/posts/${encodeURIComponent(postId)}`, context, undefined, undefined, "DELETE");
             },
-            async organizationAnalytics({ account, query, context }) {
+            async organizationAnalytics({ account, context }) {
                 authorize(account, context);
                 if (!account.accountId.startsWith("urn:li:organization:"))
                     throw new SocialError({
@@ -572,7 +865,25 @@ export function linkedin(options) {
                         operation: "analytics.organization.read",
                         message: "Organization analytics requires an organization author.",
                     });
-                return (await request(`/rest/organizationalEntityShareStatistics?q=organizationalEntity&organizationalEntity=${encodeURIComponent(account.accountId)}`, context, query));
+                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
+                return (await request(`/rest/organizationalEntityShareStatistics?q=organizationalEntity&organizationalEntity=${encodeURIComponent(account.accountId)}`, context));
+            },
+            async getOrganizationFollowerStatistics({ account, interval, context }) {
+                organizationOnly(account, context, "analytics.followers.read");
+                return parseFollowerStatistics(object(await request(statisticsPath("/rest/organizationalEntityFollowerStatistics", "organizationalEntity", account, interval), context)), interval?.granularity);
+            },
+            async getOrganizationPageStatistics({ account, interval, context }) {
+                organizationOnly(account, context, "analytics.page.read");
+                return parsePageStatistics(object(await request(statisticsPath("/rest/organizationPageStatistics", "organization", account, interval), context)), interval?.granularity);
+            },
+            async getOrganizationShareStatistics({ account, interval, context }) {
+                organizationOnly(account, context, "analytics.shares.read");
+                return parseShareStatistics(object(await request(statisticsPath("/rest/organizationalEntityShareStatistics", "organizationalEntity", account, interval), context)), interval?.granularity);
+            },
+            async getOrganizationFollowerCount({ account, context }) {
+                organizationOnly(account, context, "analytics.account.read");
+                const response = object(await request(`/rest/networkSizes/${encodeURIComponent(account.accountId)}?edgeType=COMPANY_FOLLOWED_BY_MEMBER`, context));
+                return optionalNumber(response["firstDegreeSize"]);
             },
         },
     });