@microfox/linkedin-member-data-portability/dist/index.js

A TypeScript SDK for LinkedIn Member Data Portability.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  LinkedInDataPortabilitySDK: () => LinkedInDataPortabilitySDK,
  LinkedInScope: () => import_linkedin_oauth.LinkedInScope,
  createLinkedInSDK: () => createLinkedInSDK
});
module.exports = __toCommonJS(index_exports);

// src/linkedin-member-data-portabilitySdk.ts
var import_zod = require("zod");
var import_linkedin_oauth = require("@microfox/linkedin-oauth");
var ErrorSchema = import_zod.z.object({
  message: import_zod.z.string(),
  serviceErrorCode: import_zod.z.number(),
  status: import_zod.z.number()
});
var ChangelogEventSchema = import_zod.z.object({
  id: import_zod.z.number(),
  capturedAt: import_zod.z.number(),
  processedAt: import_zod.z.number(),
  configVersion: import_zod.z.number(),
  owner: import_zod.z.string(),
  actor: import_zod.z.string(),
  resourceName: import_zod.z.string(),
  resourceId: import_zod.z.string(),
  resourceUri: import_zod.z.string(),
  method: import_zod.z.enum(["CREATE", "UPDATE", "PARTIAL_UPDATE", "DELETE"]),
  methodName: import_zod.z.string().optional(),
  activity: import_zod.z.record(import_zod.z.unknown()),
  processedActivity: import_zod.z.record(import_zod.z.unknown()),
  siblingActivities: import_zod.z.array(import_zod.z.record(import_zod.z.unknown())),
  parentSiblingActivities: import_zod.z.array(import_zod.z.record(import_zod.z.unknown())),
  activityId: import_zod.z.string(),
  activityStatus: import_zod.z.enum(["SUCCESS", "FAILURE", "SUCCESSFUL_REPLAY"])
}).describe("Changelog event schema");
var MemberSnapshotSchema = import_zod.z.object({
  snapshotDomain: import_zod.z.string(),
  snapshotData: import_zod.z.record(import_zod.z.unknown())
}).describe("Member snapshot schema");
var MemberComplianceAuthorizationSchema = import_zod.z.object({
  regulatedAt: import_zod.z.number(),
  memberComplianceAuthorizationKey: import_zod.z.object({
    developerApplication: import_zod.z.string(),
    member: import_zod.z.string()
  }),
  memberComplianceScopes: import_zod.z.array(import_zod.z.string())
}).describe("Member compliance authorization schema");
var LinkedInDataPortabilitySDK = class {
  constructor(config) {
    this.baseUrl = "https://api.linkedin.com/v2";
    this.oauthSdk = new import_linkedin_oauth.LinkedInOAuthSdk({
      clientId: config.clientId,
      clientSecret: config.clientSecret,
      redirectUri: config.redirectUri,
      scopes: [import_linkedin_oauth.LinkedInScope.OFFLINE_ACCESS, "r_dma_portability_3rd_party"]
    });
    this.accessToken = config.accessToken;
  }
  async request(endpoint, method, params) {
    const url = new URL(`${this.baseUrl}${endpoint}`);
    if (params) {
      Object.entries(params).forEach(([key, value]) => {
        url.searchParams.append(key, value);
      });
    }
    const response = await fetch(url.toString(), {
      method,
      headers: {
        Authorization: `Bearer ${this.accessToken}`,
        "LinkedIn-Version": "202312",
        "Content-Type": "application/json"
      }
    });
    if (!response.ok) {
      const error = await response.json().catch(() => ({}));
      throw new Error(
        `LinkedIn API error: ${response.status} ${response.statusText}: ${error.message}`
      );
    }
    return response.json();
  }
  async validateAccessToken() {
    try {
      const result = await this.oauthSdk.validateAccessToken(this.accessToken);
      if (!result.isValid) {
        throw new Error("Invalid access token");
      }
    } catch (error) {
      throw new Error(
        `Failed to validate access token: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }
  async refreshAccessToken(refreshToken) {
    try {
      const result = await this.oauthSdk.refreshAccessToken(refreshToken);
      this.accessToken = result.accessToken;
      return result;
    } catch (error) {
      throw new Error(
        `Failed to refresh access token: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }
  async getMemberChangeLogs(startTime) {
    await this.validateAccessToken();
    const params = { q: "memberAndApplication" };
    if (startTime) {
      params.startTime = startTime.toString();
    }
    const response = await this.request(
      "/rest/memberChangeLogs",
      "GET",
      params
    );
    return import_zod.z.array(ChangelogEventSchema).parse(response);
  }
  async getMemberSnapshotData(domain) {
    await this.validateAccessToken();
    const params = { q: "criteria" };
    if (domain) {
      params.domain = domain;
    }
    const response = await this.request(
      "/rest/memberSnapshotData",
      "GET",
      params
    );
    return import_zod.z.array(MemberSnapshotSchema).parse(response);
  }
  async getMemberAuthorizations() {
    await this.validateAccessToken();
    const response = await this.request("/rest/memberAuthorizations", "GET", { q: "memberAndApplication" });
    return MemberComplianceAuthorizationSchema.parse(response);
  }
  async triggerMemberDataProcessing() {
    await this.validateAccessToken();
    const response = await this.request(
      "/rest/memberAuthorizations",
      "POST"
    );
    return import_zod.z.object({ success: import_zod.z.boolean() }).parse(response);
  }
};
var createLinkedInSDK = (config) => {
  return new LinkedInDataPortabilitySDK(config);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  LinkedInDataPortabilitySDK,
  LinkedInScope,
  createLinkedInSDK
});
//# sourceMappingURL=index.js.map