@firedrill-tools/linkedin 0.1.1

package/firedrill/tools/linkedin/ops/comments-read.mjs

@@ -0,0 +1,57 @@
+// comments.list and comments.get.
+import { commentIdArg, loadThread } from "../lib/access.mjs";
+import { caller, checkWire } from "../lib/auth.mjs";
+import { reactionsOn, threadComments } from "../lib/cascade.mjs";
+import { notFound } from "../lib/errors.mjs";
+import { buildPage, pageArgs } from "../lib/paging.mjs";
+import { compareIds } from "../lib/postinput.mjs";
+import { renderComment } from "../lib/render.mjs";
+import { commentUrn } from "../lib/urn.mjs";
+
+const oldestFirst = (a, b) => a.createdAtMs - b.createdAtMs || compareIds(a.id, b.id);
+
+/** Groups a thread's replies by parent id once per request. */
+function repliesByParent(rows) {
+  const map = new Map();
+  for (const row of rows) {
+    if (row.parentCommentId === null) continue;
+    if (!map.has(row.parentCommentId)) map.set(row.parentCommentId, []);
+    map.get(row.parentCommentId).push(row);
+  }
+  for (const list of map.values()) list.sort(oldestFirst);
+  return map;
+}
+
+function encodePath(value) {
+  try {
+    return encodeURIComponent(value);
+  } catch {
+    return "";
+  }
+}
+
+export function listComments(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET_ALL");
+  const { post, comment, parsed } = loadThread(context, who, "target", input.target, "GET /socialActions/comments",
+    { inPath: input.wire !== undefined });
+  const { start, count } = pageArgs(context, input);
+  const rows = threadComments(context, post.activityId);
+  const replies = repliesByParent(rows);
+  const items = rows.filter((row) => (comment === null ? row.parentCommentId === null : row.parentCommentId === comment.id)).sort(oldestFirst);
+  const render = (row) => renderComment(row, reactionsOn(context, commentUrn(row.activityId, row.id)), replies.get(row.id) ?? [], who.urn);
+  return buildPage(context, items, render, { start, count, path: `/rest/socialActions/${encodePath(parsed.urn)}/comments` });
+}
+
+export function getComment(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET");
+  const inPath = input.wire !== undefined;
+  const { post } = loadThread(context, who, "target", input.target, "GET /socialActions/comments", { inPath });
+  const commentId = commentIdArg(context, input.commentId, inPath);
+  const row = context.state.get("comments", `${post.activityId}|${commentId}`);
+  if (row === null) notFound(context, `Comment ${commentId} not found`);
+  const replies = row.parentCommentId === null
+    ? threadComments(context, post.activityId).filter((reply) => reply.parentCommentId === row.id).sort(oldestFirst) : [];
+  return renderComment(row, reactionsOn(context, commentUrn(row.activityId, row.id)), replies, who.urn);
+}

package/firedrill/tools/linkedin/ops/comments-write.mjs

@@ -0,0 +1,104 @@
+// comments.create, comments.update and comments.delete.
+import { commentIdArg, loadThread } from "../lib/access.mjs";
+import { actingAs, caller, checkWire, managesAuthor, requireScope } from "../lib/auth.mjs";
+import { deleteComments, reactionsOn, threadComments } from "../lib/cascade.mjs";
+import { fail, invalidValue, missing, notFound, unprocessable } from "../lib/errors.mjs";
+import { messageArg } from "../lib/message.mjs";
+import { renderComment } from "../lib/render.mjs";
+import { nextId, nowMs } from "../lib/store.mjs";
+import { activityUrn, commentUrn, parseUrn } from "../lib/urn.mjs";
+
+const RESOURCE = "POST /socialActions/comments";
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+/** The actor a comment edit or delete acts as: `?actor=` when given, otherwise the calling member. */
+function effectiveActor(context, who, input, resource) {
+  if (input.actor !== undefined && input.actor !== null) return actingAs(context, who, "actor", input.actor, resource);
+  requireScope(context, who, ["w_member_social"], resource);
+  return { urn: who.urn, kind: "person", id: who.personId, agent: null };
+}
+
+function loadComment(context, who, input, resource) {
+  const inPath = input.wire !== undefined;
+  const thread = loadThread(context, who, "target", input.target, resource, { inPath, write: true });
+  const commentId = commentIdArg(context, input.commentId, inPath);
+  const comment = context.state.get("comments", `${thread.post.activityId}|${commentId}`);
+  if (comment === null) notFound(context, `Comment ${commentId} not found`);
+  return { ...thread, row: comment };
+}
+
+export function createComment(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "CREATE");
+  const { post, comment: targetComment } = loadThread(context, who, "target", input.target, RESOURCE,
+    { inPath: input.wire !== undefined, write: true });
+  if (input.actor === undefined || input.actor === null) missing(context, "actor");
+  const actor = actingAs(context, who, "actor", input.actor, RESOURCE);
+  if (input.content !== undefined) {
+    fail(context, "ACCESS_DENIED", "Unpermitted fields present in REQUEST_BODY: Data Processing Exception while processing fields [/content]");
+  }
+  const message = messageArg(context, input.message);
+  const thread = activityUrn(post.activityId);
+  if (input.object !== undefined && input.object !== null) {
+    const object = parseUrn(input.object);
+    const sameThread = object !== null && (input.object === thread || (object.type !== "comment" && object.type !== "activity"
+      && object.id === post.id && object.type === post.kind));
+    if (!sameThread) invalidValue(context, "object", input.object);
+  }
+  let parent = targetComment;
+  if (input.parentComment !== undefined && input.parentComment !== null) {
+    const parsed = parseUrn(input.parentComment);
+    if (parsed === null || parsed.type !== "comment" || parsed.activityId !== post.activityId
+      || (targetComment !== null && parsed.commentId !== targetComment.id)) invalidValue(context, "parentComment", input.parentComment);
+    parent = context.state.get("comments", `${parsed.activityId}|${parsed.commentId}`);
+    if (parent === null) notFound(context, `Comment ${parsed.urn} not found`);
+  }
+  if (parent !== null && parent.parentCommentId !== null) unprocessable(context, "Replies to a nested comment are not supported");
+  if (post.lifecycleState === "DRAFT") unprocessable(context, "Cannot comment on a draft post");
+  if (post.commentsState === "CLOSED") unprocessable(context, "Thread is closed to comments");
+  const now = nowMs(context);
+  const id = nextId(context);
+  const row = {
+    id, activityId: post.activityId, actor: actor.urn, agent: actor.agent, text: message.text, attributes: message.attributes,
+    parentCommentId: parent === null ? null : parent.id, createdAtMs: now, lastModifiedAtMs: now,
+  };
+  context.state.put("comments", `${post.activityId}|${id}`, row);
+  context.events.emit("comment.created", {
+    commentUrn: commentUrn(post.activityId, id), object: thread, postUrn: `urn:li:${post.kind}:${post.id}`, actor: actor.urn,
+    agent: actor.agent === null ? null : `urn:li:person:${actor.agent}`, parentComment: parent === null ? null : commentUrn(post.activityId, parent.id),
+    created: now,
+  });
+  return renderComment(row, [], [], who.urn);
+}
+
+export function updateComment(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "PARTIAL_UPDATE");
+  const { row } = loadComment(context, who, input, "POST /socialActions/comments");
+  if (typeof input.wire?.fieldError === "string") invalidValue(context, input.wire.fieldError, "an unsupported patch");
+  const actor = effectiveActor(context, who, input, "POST /socialActions/comments");
+  if (actor.urn !== row.actor) fail(context, "ACCESS_DENIED", "Not enough permissions to edit this comment");
+  const message = messageArg(context, input.message);
+  const urn = commentUrn(row.activityId, row.id);
+  const replies = row.parentCommentId === null ? threadComments(context, row.activityId).filter((c) => c.parentCommentId === row.id) : [];
+  if (message.text === row.text && sameJson(message.attributes, row.attributes)) {
+    return renderComment(row, reactionsOn(context, urn), replies, who.urn);
+  }
+  const next = { ...row, text: message.text, attributes: message.attributes, lastModifiedAtMs: nowMs(context) };
+  context.state.put("comments", `${row.activityId}|${row.id}`, next);
+  return renderComment(next, reactionsOn(context, urn), replies, who.urn);
+}
+
+export function deleteComment(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "DELETE");
+  const { post, row } = loadComment(context, who, input, "DELETE /socialActions/comments");
+  const actor = effectiveActor(context, who, input, "DELETE /socialActions/comments");
+  if (actor.urn !== row.actor && !managesAuthor(context, who, post.author)) {
+    fail(context, "ACCESS_DENIED", "Not enough permissions to delete this comment");
+  }
+  const replies = row.parentCommentId === null ? threadComments(context, row.activityId).filter((c) => c.parentCommentId === row.id) : [];
+  const deletedReplies = deleteComments(context, replies);
+  deleteComments(context, [row]);
+  return { commentUrn: commentUrn(row.activityId, row.id), deleted: true, deletedReplies };
+}

package/firedrill/tools/linkedin/ops/feed.mjs

@@ -0,0 +1,74 @@
+// feed.list: reverse-chronological home feed of the caller, its connections and followed or managed organizations.
+import { visibility } from "../lib/access.mjs";
+import { caller, requireScope } from "../lib/auth.mjs";
+import { buildPage, pageArgs } from "../lib/paging.mjs";
+import { compareIds } from "../lib/postinput.mjs";
+import { fullName, renderPost } from "../lib/render.mjs";
+import { reactionSummaries, summarize } from "../lib/social.mjs";
+import { scanValues } from "../lib/store.mjs";
+import { organizationUrn, parseUrn, postUrnOf } from "../lib/urn.mjs";
+
+function actorInfo(context, urn) {
+  const parsed = parseUrn(urn);
+  if (parsed?.type === "organization") {
+    const org = context.state.get("organizations", parsed.id);
+    return { urn, kind: "organization", name: org?.name ?? "LinkedIn Member", headline: null, vanityName: org?.vanityName ?? "" };
+  }
+  const person = parsed === null ? null : context.state.get("people", parsed.id);
+  return { urn, kind: "person", name: person === null ? "LinkedIn Member" : fullName(person), headline: person?.headline ?? null,
+    vanityName: person?.vanityName ?? "" };
+}
+
+export function listFeed(input, context) {
+  const who = caller(context);
+  requireScope(context, who, ["r_member_social"], "GET /feed");
+  const { start, count } = pageArgs(context, input, { defaultCount: 10, maxCount: 50 });
+  const connections = new Set(scanValues(context, "connections", `${who.personId}|`).map((edge) => edge.connectedPersonId));
+  const pages = new Map();
+  for (const acl of scanValues(context, "organization-acls")) {
+    if (acl.personId !== who.personId || acl.state !== "APPROVED") continue;
+    if (!pages.has(acl.organizationId)) pages.set(acl.organizationId, []);
+    pages.get(acl.organizationId).push(acl.role);
+  }
+  const followed = new Set([...who.person.followingOrganizationIds.map(String), ...[...pages.keys()].map(String)]);
+  const all = scanValues(context, "posts");
+  const byUrn = new Map(all.map((post) => [postUrnOf(post), post]));
+  const reposts = new Map();
+  for (const post of all) {
+    if (post.reshareParent !== null && post.deletedAtMs === null && post.lifecycleState === "PUBLISHED") {
+      reposts.set(post.reshareParent, (reposts.get(post.reshareParent) ?? 0) + 1);
+    }
+  }
+  const inNetwork = (author) => {
+    if (author === who.urn) return true;
+    const parsed = parseUrn(author);
+    return parsed !== null && (parsed.type === "person" ? connections.has(parsed.id) : followed.has(parsed.id));
+  };
+  const items = all
+    .filter((post) => post.lifecycleState === "PUBLISHED" && inNetwork(post.author) && visibility(context, who, post) === "ok")
+    .sort((a, b) => b.publishedAtMs - a.publishedAtMs || compareIds(b.id, a.id));
+  const render = (post) => {
+    const { commentSummary, reactions } = summarize(context, post, null);
+    const parent = post.reshareParent === null ? null : byUrn.get(post.reshareParent) ?? null;
+    const showParent = parent !== null && parent.lifecycleState === "PUBLISHED" && visibility(context, who, parent) === "ok";
+    return {
+      post: renderPost(post), actor: actorInfo(context, post.author),
+      reshareOf: showParent ? { post: renderPost(parent), actor: actorInfo(context, parent.author) } : null,
+      social: { reactionSummaries: reactionSummaries(reactions), commentSummary, commentsState: post.commentsState,
+        repostCount: reposts.get(postUrnOf(post)) ?? 0 },
+      viewerReaction: reactions.find((reaction) => reaction.actor === who.urn)?.reactionType ?? null,
+    };
+  };
+  const page = buildPage(context, items, render, { start, count, path: "/v1/operations/linkedin/feed.list" });
+  const nowMs = Math.floor(context.clock.nowUs() / 1000);
+  const viewerPages = [...pages.entries()].map(([organizationId, roles]) => {
+    const org = context.state.get("organizations", String(organizationId));
+    return { organizationUrn: organizationUrn(organizationId), name: org?.name ?? "", vanityName: org?.vanityName ?? "", roles: roles.sort() };
+  });
+  return {
+    serverTime: new Date(nowMs).toISOString(), serverTimeMs: nowMs,
+    viewer: { personUrn: who.urn, name: fullName(who.person), headline: who.person.headline, vanityName: who.person.vanityName,
+      connectionCount: connections.size, pages: viewerPages },
+    ...page,
+  };
+}

package/firedrill/tools/linkedin/ops/network.mjs

@@ -0,0 +1,46 @@
+// network_sizes.get and connections.list.
+import { caller, checkWire, requireScope, urnField } from "../lib/auth.mjs";
+import { fail, invalidValue, missing, notFound } from "../lib/errors.mjs";
+import { buildPage, pageArgs } from "../lib/paging.mjs";
+import { liteProfile } from "../lib/render.mjs";
+import { scanPrefix, scanValues } from "../lib/store.mjs";
+import { fold } from "../lib/text.mjs";
+
+export function getNetworkSize(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET");
+  const entity = urnField(context, "entity", input.entity, ["organization", "person"], { inPath: input.wire !== undefined });
+  if (entity.type === "organization") {
+    requireScope(context, who, ["rw_organization_admin", "r_organization_social"], "GET /networkSizes");
+    if (input.edgeType === undefined || input.edgeType === null) missing(context, "edgeType");
+    if (input.edgeType !== "COMPANY_FOLLOWED_BY_MEMBER") invalidValue(context, "edgeType", input.edgeType);
+    const org = context.state.get("organizations", entity.id);
+    if (org === null) notFound(context, `Organization ${entity.id} is inactive`);
+    return { firstDegreeSize: org.followerCount };
+  }
+  requireScope(context, who, ["r_1st_connections_size"], "GET /connections");
+  if (input.edgeType !== undefined && input.edgeType !== null) invalidValue(context, "edgeType", input.edgeType);
+  if (entity.id !== who.personId) fail(context, "ACCESS_DENIED", `Not enough permissions to access: GET /connections for ${entity.urn}`);
+  return { firstDegreeSize: scanPrefix(context, "connections", `${who.personId}|`).length };
+}
+
+export function listConnections(input, context) {
+  const who = caller(context);
+  requireScope(context, who, ["r_1st_connections_size"], "GET /connections");
+  const query = input.query ?? "";
+  if (typeof query !== "string" || query.length > 100 || query.includes("�")) invalidValue(context, "query", query);
+  const { start, count } = pageArgs(context, input, { defaultCount: 20, maxCount: 100 });
+  const needle = fold(query.trim());
+  const rows = [];
+  for (const edge of scanValues(context, "connections", `${who.personId}|`)) {
+    const person = context.state.get("people", edge.connectedPersonId);
+    if (person === null) continue;
+    const haystacks = [person.firstName, person.lastName, person.headline ?? ""].map(fold);
+    if (needle !== "" && !haystacks.some((text) => text.includes(needle))) continue;
+    rows.push({ person, connectedAt: edge.connectedAtMs });
+  }
+  rows.sort((a, b) => b.connectedAt - a.connectedAt || (a.person.id < b.person.id ? -1 : a.person.id > b.person.id ? 1 : 0));
+  return buildPage(context, rows, (row) => ({ person: liteProfile(row.person), connectedAt: row.connectedAt }), {
+    start, count, path: "/v1/operations/linkedin/connections.list", query: needle === "" ? [] : [["query", query]],
+  });
+}

package/firedrill/tools/linkedin/ops/orgs.mjs

@@ -0,0 +1,93 @@
+// organizations.get, organizations.find_by_vanity_name and organization_acls.list.
+import { caller, checkWire, requireScope, rolesOn, urnField } from "../lib/auth.mjs";
+import { badRequest, fail, invalidValue, missing, notFound } from "../lib/errors.mjs";
+import { buildPage, pageArgs } from "../lib/paging.mjs";
+import { scanValues } from "../lib/store.mjs";
+import { organizationUrn, personUrn } from "../lib/urn.mjs";
+
+const ORG_ID = /^[1-9][0-9]{0,11}$/;
+const ROLES = new Set(["ADMINISTRATOR", "DIRECT_SPONSORED_CONTENT_POSTER", "RECRUITING_POSTER", "LEAD_CAPTURE_ADMINISTRATOR",
+  "LEAD_GEN_FORMS_MANAGER", "ANALYST", "CURATOR", "CONTENT_ADMINISTRATOR"]);
+const STATES = new Set(["APPROVED", "REQUESTED", "REJECTED", "REVOKED"]);
+
+const localized = (org, value) => ({
+  localized: { [`${org.localeLanguage}_${org.localeCountry}`]: value }, preferredLocale: { country: org.localeCountry, language: org.localeLanguage },
+});
+const locations = (org) => org.locations.map((location) => ({
+  address: { city: location.city, country: location.country, ...(location.geographicArea === null ? {} : { geographicArea: location.geographicArea }),
+    ...(location.postalCode === null ? {} : { postalCode: location.postalCode }) },
+  locationType: "OTHER",
+}));
+
+function nonAdminFields(org) {
+  return {
+    id: org.id, name: localized(org, org.name), localizedName: org.name, ...(org.website === null ? {} : { localizedWebsite: org.website }),
+    vanityName: org.vanityName, locations: locations(org), primaryOrganizationType: org.primaryOrganizationType,
+  };
+}
+
+export function getOrganization(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET");
+  requireScope(context, who, ["rw_organization_admin"], "GET /organizations");
+  const id = input.organizationId;
+  if (typeof id !== "string" || !ORG_ID.test(id)) badRequest(context, "Syntax exception in path variables");
+  const org = context.state.get("organizations", id);
+  if (org === null) notFound(context, `Organization ${id} is inactive`);
+  if (!rolesOn(context, id, who.personId).has("ADMINISTRATOR")) {
+    fail(context, "ACCESS_DENIED", `Viewer don't have permission to the ADMIN_ONLY VisibilityReduction for urn:li:organization:${id}`);
+  }
+  return {
+    ...nonAdminFields(org), $URN: organizationUrn(id),
+    ...(org.description === null ? {} : { localizedDescription: org.description, description: localized(org, org.description) }),
+    ...(org.website === null ? {} : { website: localized(org, org.website) }),
+    industries: org.industries, staffCountRange: org.staffCountRange, organizationType: org.organizationType,
+    ...(org.foundedOn === null ? {} : { foundedOn: org.foundedOn }),
+    defaultLocale: { country: org.localeCountry, language: org.localeLanguage }, versionTag: String(org.createdAtMs % 1000000),
+    alternativeNames: [], specialties: [], localizedSpecialties: [], groups: [],
+  };
+}
+
+export function findByVanityName(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "FINDER");
+  requireScope(context, who, ["rw_organization_admin", "r_organization_social"], "GET /organizations");
+  const vanity = input.vanityName;
+  if (typeof vanity !== "string" || !/^[A-Za-z0-9-]{1,100}$/.test(vanity)) invalidValue(context, "vanityName", vanity);
+  const entry = context.state.get("org-vanity", vanity.toLowerCase());
+  const org = entry === null ? null : context.state.get("organizations", String(entry.organizationId));
+  const elements = org === null ? [] : [nonAdminFields(org)];
+  return { paging: { start: 0, count: 10, links: [], total: elements.length }, elements };
+}
+
+export function listAcls(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "FINDER");
+  requireScope(context, who, ["rw_organization_admin"], "GET /organizationAcls");
+  if (input.q === undefined || input.q === null) missing(context, "q");
+  if (input.q !== "roleAssignee" && input.q !== "organization") invalidValue(context, "q", input.q);
+  if (input.role !== undefined && input.role !== null && !(typeof input.role === "string" && ROLES.has(input.role))) invalidValue(context, "role", input.role);
+  if (input.state !== undefined && input.state !== null && !(typeof input.state === "string" && STATES.has(input.state))) {
+    invalidValue(context, "state", input.state);
+  }
+  const { start, count } = pageArgs(context, input);
+  let rows;
+  let target = null;
+  if (input.q === "organization") {
+    target = urnField(context, "organization", input.organization, ["organization"]);
+    if (context.state.get("organizations", target.id) === null) notFound(context, `Organization ${target.id} is inactive`);
+    if (!rolesOn(context, target.id, who.personId).has("ADMINISTRATOR")) {
+      fail(context, "ACCESS_DENIED", `Not enough permissions to access: GET /organizationAcls for ${target.urn}`);
+    }
+    rows = scanValues(context, "organization-acls", `${target.id}|`);
+  } else {
+    rows = scanValues(context, "organization-acls").filter((acl) => acl.personId === who.personId);
+  }
+  rows = rows.filter((acl) => (input.role == null || acl.role === input.role) && (input.state == null || acl.state === input.state));
+  const field = target === null ? "organization" : "organizationTarget";
+  const render = (acl) => ({ role: acl.role, [field]: organizationUrn(acl.organizationId), roleAssignee: personUrn(acl.personId), state: acl.state });
+  return buildPage(context, rows, render, {
+    start, count, path: "/rest/organizationAcls",
+    query: [["q", input.q], ["organization", target?.urn], ["role", input.role], ["state", input.state]],
+  });
+}

package/firedrill/tools/linkedin/ops/posts-edit.mjs

@@ -0,0 +1,71 @@
+// posts.update (partial update) and posts.delete (idempotent tombstone with cascade).
+import { findPost, visibility } from "../lib/access.mjs";
+import { caller, checkWire, managesAuthor, requireScope, urnField } from "../lib/auth.mjs";
+import { deleteThread } from "../lib/cascade.mjs";
+import { blank, fail, invalidValue, missing, notFound } from "../lib/errors.mjs";
+import { commentaryArg } from "../lib/postinput.mjs";
+import { renderPost } from "../lib/render.mjs";
+import { nowMs } from "../lib/store.mjs";
+import { activityUrn, parseUrn, personUrn, postUrnOf } from "../lib/urn.mjs";
+
+/** Loads a post the caller may manage (author, or a poster of the authoring page) and checks the write scope. */
+function managedPost(context, who, input, resource) {
+  const parsed = urnField(context, "postUrn", input.postUrn, ["share", "ugcPost"], { inPath: input.wire !== undefined });
+  const post = findPost(context, parsed);
+  if (post === null) notFound(context, `Post ${parsed.urn} not found`);
+  const organization = parseUrn(post.author)?.type === "organization";
+  requireScope(context, who, [organization ? "w_organization_social" : "w_member_social"], resource);
+  const seen = post.deletedAtMs === null ? visibility(context, who, post, "AUTHOR") : "ok";
+  if (seen === "missing") notFound(context, `Post ${parsed.urn} not found`);
+  if (seen === "hidden" || !managesAuthor(context, who, post.author)) {
+    fail(context, "ACCESS_DENIED", `Not enough permissions to access: ${resource} ${parsed.urn}`);
+  }
+  return { post, parsed };
+}
+
+export function updatePost(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "PARTIAL_UPDATE");
+  const { post, parsed } = managedPost(context, who, input, "POST /posts");
+  if (typeof input.wire?.fieldError === "string") invalidValue(context, input.wire.fieldError, "an unsupported patch");
+  if (post.deletedAtMs !== null) notFound(context, `Post ${parsed.urn} not found`);
+  const fields = ["commentary", "lifecycleState", "contentCallToActionLabel", "contentLandingPage"].filter((f) => input[f] !== undefined);
+  if (fields.length === 0) missing(context, "patch/$set");
+  if (input.contentCallToActionLabel !== undefined) invalidValue(context, "contentCallToActionLabel", input.contentCallToActionLabel);
+  if (input.contentLandingPage !== undefined) invalidValue(context, "contentLandingPage", input.contentLandingPage);
+  const next = { ...post };
+  if (input.lifecycleState !== undefined) {
+    if (input.lifecycleState !== "PUBLISHED") invalidValue(context, "lifecycleState", input.lifecycleState);
+    next.lifecycleState = "PUBLISHED";
+  }
+  if (input.commentary !== undefined) {
+    const commentary = commentaryArg(context, input.commentary);
+    if (commentary === "" && post.article === null && post.reshareParent === null) blank(context, "commentary");
+    next.commentary = commentary;
+    if (commentary !== post.commentary && post.lifecycleState === "PUBLISHED") next.isEditedByAuthor = true;
+  }
+  const publishing = post.lifecycleState === "DRAFT" && next.lifecycleState === "PUBLISHED";
+  if (!publishing && next.commentary === post.commentary && next.isEditedByAuthor === post.isEditedByAuthor) return renderPost(post);
+  const now = nowMs(context);
+  next.lastModifiedAtMs = now;
+  if (publishing) next.publishedAtMs = now;
+  context.state.put("posts", post.id, next);
+  if (publishing) {
+    context.events.emit("post.published", {
+      postUrn: postUrnOf(next), activityUrn: activityUrn(next.activityId), author: next.author, visibility: next.visibility,
+      reshareParent: next.reshareParent, publishedAt: now, createdBy: personUrn(who.personId),
+    });
+  }
+  return renderPost(next);
+}
+
+export function deletePost(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "DELETE");
+  const { post, parsed } = managedPost(context, who, input, "DELETE /posts");
+  if (post.deletedAtMs !== null) return { id: parsed.urn, deleted: true };
+  deleteThread(context, post.activityId);
+  const now = nowMs(context);
+  context.state.put("posts", post.id, { ...post, commentary: "", article: null, deletedAtMs: now, lastModifiedAtMs: now });
+  return { id: parsed.urn, deleted: true };
+}

package/firedrill/tools/linkedin/ops/posts-read.mjs

@@ -0,0 +1,54 @@
+// posts.get and posts.list_by_author.
+import { loadVisiblePost } from "../lib/access.mjs";
+import { READER_ROLES, caller, checkWire, holdsAny, managesAuthor, requireScope, rolesOn, urnField } from "../lib/auth.mjs";
+import { fail, invalidValue, notFound } from "../lib/errors.mjs";
+import { buildPage, pageArgs } from "../lib/paging.mjs";
+import { compareIds } from "../lib/postinput.mjs";
+import { renderPost } from "../lib/render.mjs";
+import { scanValues } from "../lib/store.mjs";
+
+const VIEW_CONTEXTS = new Set(["READER", "AUTHOR"]);
+const SORTS = new Set(["LAST_MODIFIED", "CREATED"]);
+
+export function viewContextArg(context, value) {
+  if (value === undefined || value === null) return "READER";
+  if (typeof value !== "string" || !VIEW_CONTEXTS.has(value)) return invalidValue(context, "viewContext", value);
+  return value;
+}
+
+export function getPost(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET");
+  const parsed = urnField(context, "postUrn", input.postUrn, ["share", "ugcPost"], { inPath: input.wire !== undefined });
+  const viewContext = viewContextArg(context, input.viewContext);
+  return renderPost(loadVisiblePost(context, who, parsed, "GET /posts", viewContext));
+}
+
+export function listByAuthor(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "FINDER");
+  const author = urnField(context, "author", input.author, ["person", "organization"]);
+  const viewContext = viewContextArg(context, input.viewContext);
+  const sortBy = input.sortBy ?? "LAST_MODIFIED";
+  if (typeof sortBy !== "string" || !SORTS.has(sortBy)) invalidValue(context, "sortBy", sortBy);
+  const { start, count } = pageArgs(context, input);
+  if (author.type === "person") {
+    requireScope(context, who, ["r_member_social"], "GET /posts");
+    if (author.id !== who.personId) fail(context, "ACCESS_DENIED", `Not enough permissions to access: GET /posts for ${author.urn}`);
+  } else {
+    requireScope(context, who, ["r_organization_social"], "GET /posts");
+    if (context.state.get("organizations", author.id) === null) notFound(context, `Organization ${author.id} is inactive`);
+    if (!holdsAny(rolesOn(context, author.id, who.personId), READER_ROLES)) {
+      fail(context, "ACCESS_DENIED", `Not enough permissions to access: GET /posts for ${author.urn}`);
+    }
+  }
+  const withDrafts = viewContext === "AUTHOR" && managesAuthor(context, who, author.urn);
+  const key = sortBy === "CREATED" ? "createdAtMs" : "lastModifiedAtMs";
+  const posts = scanValues(context, "posts")
+    .filter((post) => post.author === author.urn && post.deletedAtMs === null && (post.lifecycleState === "PUBLISHED" || withDrafts))
+    .sort((a, b) => b[key] - a[key] || compareIds(b.id, a.id));
+  return buildPage(context, posts, renderPost, {
+    start, count, path: "/rest/posts",
+    query: [["q", "author"], ["author", author.urn], ["viewContext", input.viewContext], ["sortBy", input.sortBy]],
+  });
+}

package/firedrill/tools/linkedin/ops/posts-write.mjs

@@ -0,0 +1,74 @@
+// posts.create, posts.update and posts.delete.
+import { findPost, visibility } from "../lib/access.mjs";
+import { actingAs, caller, checkWire, urnField } from "../lib/auth.mjs";
+import { blank, invalidValue, missing, notFound, unprocessable } from "../lib/errors.mjs";
+import { FEED_DISTRIBUTIONS, VISIBILITIES, commentaryArg, contentArg } from "../lib/postinput.mjs";
+import { renderPost } from "../lib/render.mjs";
+import { nextId, nowMs } from "../lib/store.mjs";
+import { activityUrn, personUrn, postUrnOf } from "../lib/urn.mjs";
+
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+function emitPublished(context, post, who) {
+  context.events.emit("post.published", {
+    postUrn: postUrnOf(post), activityUrn: activityUrn(post.activityId), author: post.author, visibility: post.visibility,
+    reshareParent: post.reshareParent, publishedAt: post.publishedAtMs, createdBy: personUrn(who.personId),
+  });
+}
+
+function distributionArg(context, distribution) {
+  if (distribution === undefined || distribution === null) return missing(context, "distribution");
+  if (!isObject(distribution)) return invalidValue(context, "distribution", distribution);
+  const feed = distribution.feedDistribution;
+  if (feed === undefined || feed === null) return missing(context, "distribution/feedDistribution");
+  if (typeof feed !== "string" || !FEED_DISTRIBUTIONS.has(feed)) return invalidValue(context, "distribution/feedDistribution", feed);
+  for (const field of ["targetEntities", "thirdPartyDistributionChannels"]) {
+    const value = distribution[field];
+    if (value !== undefined && value !== null && (!Array.isArray(value) || value.length > 0)) invalidValue(context, `distribution/${field}`, value);
+  }
+  return feed;
+}
+
+function reshareArg(context, who, reshareContext) {
+  if (reshareContext === undefined || reshareContext === null) return null;
+  if (!isObject(reshareContext)) return invalidValue(context, "reshareContext", reshareContext);
+  const parsed = urnField(context, "reshareContext/parent", reshareContext.parent, ["share", "ugcPost"]);
+  const parent = findPost(context, parsed);
+  if (parent === null || parent.deletedAtMs !== null) notFound(context, `Post ${parsed.urn} not found`);
+  if (parent.lifecycleState === "DRAFT") unprocessable(context, "Cannot reshare a draft post");
+  if (visibility(context, who, parent) !== "ok") notFound(context, `Post ${parsed.urn} not found`);
+  if (parent.isReshareDisabledByAuthor) unprocessable(context, "Reshare is disabled by the author");
+  return { parent: parsed.urn, root: parent.reshareRoot ?? parsed.urn };
+}
+
+export function createPost(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "CREATE");
+  if (input.author === undefined || input.author === null) missing(context, "author");
+  const actor = actingAs(context, who, "author", input.author, "POST /posts");
+  if (input.visibility === undefined || input.visibility === null) missing(context, "visibility");
+  if (typeof input.visibility !== "string" || !VISIBILITIES.has(input.visibility)) invalidValue(context, "visibility", input.visibility);
+  if (actor.kind === "organization" && input.visibility === "CONNECTIONS") invalidValue(context, "visibility", input.visibility);
+  const feedDistribution = distributionArg(context, input.distribution);
+  if (input.lifecycleState === undefined || input.lifecycleState === null) missing(context, "lifecycleState");
+  if (input.lifecycleState !== "PUBLISHED") invalidValue(context, "lifecycleState", input.lifecycleState);
+  const article = contentArg(context, input.content);
+  const reshare = reshareArg(context, who, input.reshareContext);
+  const commentary = commentaryArg(context, input.commentary);
+  if (commentary === "" && article === null && reshare === null) blank(context, "commentary");
+  const reshareDisabled = input.isReshareDisabledByAuthor ?? false;
+  if (typeof reshareDisabled !== "boolean") invalidValue(context, "isReshareDisabledByAuthor", reshareDisabled);
+  const now = nowMs(context);
+  const id = nextId(context);
+  const activityId = nextId(context);
+  const post = {
+    id, kind: input.kind === "ugcPost" ? "ugcPost" : "share", activityId, author: actor.urn, commentary, visibility: input.visibility,
+    feedDistribution, lifecycleState: "PUBLISHED", isReshareDisabledByAuthor: reshareDisabled, isEditedByAuthor: false, article,
+    reshareParent: reshare?.parent ?? null, reshareRoot: reshare?.root ?? null, commentsState: "OPEN", createdBy: who.personId,
+    createdAtMs: now, lastModifiedAtMs: now, publishedAtMs: now, deletedAtMs: null,
+  };
+  context.state.put("posts", id, post);
+  context.state.put("activities", activityId, { postId: id });
+  emitPublished(context, post, who);
+  return renderPost(post);
+}

package/firedrill/tools/linkedin/ops/profile.mjs

@@ -0,0 +1,38 @@
+// profile.userinfo, profile.me and people.get.
+import { caller, checkWire, requireScope } from "../lib/auth.mjs";
+import { badRequest, fail, notFound } from "../lib/errors.mjs";
+import { fullName, liteProfile } from "../lib/render.mjs";
+
+const PERSON_ID = /^[A-Za-z0-9_-]{10}$/;
+
+export function userinfo(input, context) {
+  const who = caller(context);
+  if (!who.scopes.has("openid") || !who.scopes.has("profile")) fail(context, "ACCESS_DENIED", "Not enough permissions to access: GET /userinfo");
+  const person = who.person;
+  return {
+    sub: person.id,
+    name: fullName(person),
+    given_name: person.firstName,
+    family_name: person.lastName,
+    ...(person.pictureUrl === null ? {} : { picture: person.pictureUrl }),
+    locale: `${person.locale.language}-${person.locale.country}`,
+    ...(who.scopes.has("email") && person.email !== null ? { email: person.email, email_verified: person.emailVerified } : {}),
+  };
+}
+
+export function me(input, context) {
+  const who = caller(context);
+  requireScope(context, who, ["profile"], "GET /me");
+  return liteProfile(who.person);
+}
+
+export function getPerson(input, context) {
+  const who = caller(context);
+  checkWire(context, input, "GET", false);
+  requireScope(context, who, ["profile"], "GET /people");
+  const personId = input.personId;
+  if (typeof personId !== "string" || !PERSON_ID.test(personId)) badRequest(context, "Syntax exception in path variables");
+  const person = context.state.get("people", personId);
+  if (person === null) notFound(context, `Member ${personId} not found`);
+  return liteProfile(person);
+}