@code.store/arcxp-sdk-ts 1.0.0

package/src/api/migration-center/types.ts

@@ -0,0 +1,181 @@
+import { AStory, AnImage, Tag } from '../../types/story';
+
+type TagANS = Tag & { name: string };
+
+type AuthorANS = {
+  type: 'author';
+  _id: string;
+  firstName: string;
+  lastName: string;
+  byline: string;
+  email: string;
+  affiliations: string;
+  education: { name: string }[];
+  awards: { name: string }[];
+  bio_page: string;
+  bio: string;
+  longBio: string;
+  slug: string;
+  native_app_rendering: boolean;
+  fuzzy_match: boolean;
+  contributor: boolean;
+  location: string;
+  role: string;
+  expertise: string;
+  personal_website: string;
+  twitter: string;
+  facebook: string;
+  linkedin: string;
+  status: boolean;
+};
+
+export type SectionReference = {
+  type: 'reference';
+  referent: {
+    id: string;
+    website: string;
+    type: 'section';
+  };
+};
+
+export type PostANSPayload = {
+  sourceId: string;
+  sourceType: string;
+  ANS: AStory | AnImage | AuthorANS | TagANS;
+  references?: unknown[];
+  circulations?: [
+    {
+      document_id: string;
+      website_id: string;
+      website_url?: string;
+      primary_section: SectionReference;
+      website_primary_section: SectionReference;
+      website_sections: SectionReference[];
+    }
+  ];
+  operations?: {
+    type: string;
+    story_id: string;
+    operation: string;
+    date: string;
+    organization_id: string;
+    endpoint: string;
+  }[];
+  arcAdditionalProperties?: {
+    importPriority?: string;
+    story?: {
+      publish: boolean;
+    };
+    video?: {
+      transcoding: true;
+      useLastUpdated: true;
+      importPriority: string;
+      thumbnailTimeInSeconds: 0;
+    };
+  };
+};
+
+export type PostANSParams = {
+  website: string;
+  groupId: string;
+  priority: 'historical';
+};
+
+export type GetANSParams = {
+  ansId: string;
+  ansType: string;
+};
+
+export enum ANSType {
+  Story = 'story',
+  Video = 'video',
+  Tag = 'tag',
+  Author = 'author',
+  Gallery = 'gallery',
+  Image = 'image',
+  Redirect = 'redirect',
+}
+
+export enum MigrationStatus {
+  Success = 'Success',
+  Queued = 'Queued',
+  Circulated = 'Circulated',
+  Published = 'Published',
+  Scheduled = 'Scheduled',
+  FailVideo = 'FailVideo',
+  FailImage = 'FailImage',
+  FailStory = 'FailStory',
+  FailGallery = 'FailGallery',
+  FailAuthor = 'FailAuthor',
+  FailTag = 'FailTag',
+  ValidationFailed = 'ValidationFailed',
+}
+
+export type Summary = SummaryRecord[];
+
+export type SummaryRecord = {
+  id: number;
+  sourceId: string;
+  sourceType: string;
+  sourceLocation: string;
+  sourceAdditionalProperties: string;
+  ansId: string;
+  ansType: string;
+  ansLocation: string;
+  status: MigrationStatus;
+  website: string;
+  operations: string;
+  circulationLocation: string;
+  createDate: string;
+  updateDate: string;
+  errorMessage?: string;
+  priority: string;
+  arcAdditionalProperties: string;
+  groupId: string;
+  tags?: null;
+};
+
+export type DetailReport = SummaryRecord & { ansContent: AStory | AnImage | AuthorANS | TagANS };
+
+export type Count = {
+  historical: {
+    total: number;
+    ansTypes: Partial<{
+      tag: ANSTypeCount;
+      story: ANSTypeCount;
+      author: ANSTypeCount;
+      image: ANSTypeCount;
+    }>;
+  };
+};
+
+type ANSTypeCount = Partial<Record<MigrationStatus, number>>;
+
+export type DetailReportRequest = {
+  sourceId?: string;
+  sourceType?: string;
+  ansId?: string;
+  ansType?: string;
+  version?: string;
+  documentType?: string;
+};
+
+export type SummaryReportRequest = {
+  status?: MigrationStatus;
+  website: string;
+  groupId?: string;
+  fetchFromId?: string;
+  sort: SummarySortBy;
+  sortOrder: SummarySortOrder;
+};
+
+export enum SummarySortBy {
+  CreateDate = 'createDate',
+  UpdateDate = 'updateDate',
+  Id = 'id',
+}
+
+export enum SummarySortOrder {
+  ASC = 'ASC',
+  DESC = 'DESC',
+}

package/src/api/sales/index.ts

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+import FormData from 'form-data';
+import { MigrateBatchResponse } from './types';
+
+export class ArcSales extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'sales/api/v1' });
+  }
+
+  async migrate(filePath: string) {
+    const form = new FormData();
+    const file = await readFile(filePath);
+    form.append('file', file, { filename: 'subs.json' });
+
+    const { data } = await this.client.post<MigrateBatchResponse>('/migrate', form, {
+      headers: { ...form.getHeaders() },
+    });
+
+    return data;
+  }
+}

package/src/api/sales/types.ts

@@ -0,0 +1,73 @@
+export type BatchSubscriptionMigrate = {
+  subscriptions: (PaidSubscription | FreeSubscription)[];
+  payments: PaymentInfo[];
+};
+
+interface BaseSubscription {
+  type: string;
+  legacyID: string;
+  ownerClientID: string;
+  sku: string;
+  priceCode: string;
+  currentCycle: number;
+  nextEventDateUTC: string;
+  paymentMethod?: Record<string, any>;
+}
+
+export interface PaidSubscription extends BaseSubscription {
+  legacyID: string;
+  ownerClientID: string;
+  sku: string;
+  priceCode: string;
+  currentCycle: number;
+  nextEventDateUTC: string;
+  type: 'paid';
+  paymentMethod: {
+    providerID: number;
+    token: string;
+  };
+  billingAddress: {
+    line1?: string | null | undefined;
+    line2?: string | null | undefined;
+    locality?: string | null | undefined;
+    region?: string | null | undefined;
+    postal?: string | null | undefined;
+    country: string;
+  };
+}
+
+export interface FreeSubscription extends BaseSubscription {
+  type: 'free';
+  paymentMethod: {
+    providerID: number;
+    token: string;
+  };
+}
+
+export type PaymentInfo = {
+  legacySubscriptionID: string;
+  type: 'payment';
+  paymentDateUTC: string;
+  amount: number;
+  currency: string;
+  tax: number;
+  periodFromUTC?: string;
+  periodUntilUTC?: string;
+  refunds: null | Refund[];
+};
+
+export type Refund = {
+  /**
+   * 'YYYY-MM-DD HH24:mm – e.g. 2019-04-25 01:02 – refund date';
+   */
+  refundDateUTC: string;
+  amount: number;
+  currency: string;
+  tax: number;
+  providerReference?: string;
+};
+
+export type MigrateBatchResponse = {
+  subscriptionsInBatch?: number;
+  batchID?: string;
+};

package/src/api/site/index.ts

@@ -0,0 +1,20 @@
+import { Section, SetSection } from '../../types/section';
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+
+export class ArcSite extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'site/v3' });
+  }
+
+  async getSection(id: string, website: string) {
+    const { data } = await this.client.get<Section>(`/website/${website}/section?_id=${id}`);
+
+    return data;
+  }
+
+  async putSection(section: SetSection) {
+    const { data } = await this.client.put(`/website/${section.website}/section?_id=${section._id}`, section);
+
+    return data;
+  }
+}

package/src/api/ws.client.ts

@@ -0,0 +1,73 @@
+import ws from 'ws';
+
+export type PromiseOr<T> = Promise<T> | T;
+export type Callback<Args extends any[] = any[]> = (...args: Args) => PromiseOr<void>;
+
+export default class WsClient {
+  private socket?: ws.WebSocket;
+
+  constructor(private address: string, private readonly options: ws.ClientOptions) {}
+
+  onOpen?: Callback<[]>;
+  onMessage?: Callback<[any]>;
+  onClose?: Callback<[ws.CloseEvent | void]>;
+
+  async connect() {
+    if (this.socket && this.socket.readyState === this.socket.OPEN) return;
+
+    const socket = new ws.WebSocket(this.address, this.options);
+    this._closing = false;
+    socket.onclose = (event) => this.close(event);
+
+    await new Promise((resolve, reject) => {
+      socket.onerror = (error) => reject(error);
+      socket.onopen = () => resolve(true);
+    });
+    socket.onmessage = ({ data }) => {
+      let message: Record<string, any>;
+      try {
+        message = JSON.parse(data.toString());
+      } catch (error) {
+        throw new Error('failed to parse message');
+      }
+
+      this.onMessage?.(message);
+    };
+
+    this.socket = socket;
+    this.onOpen?.();
+  }
+
+  private _closing = false;
+  close(event?: ws.CloseEvent) {
+    if (this._closing) return;
+    this._closing = true;
+    this.socket?.close();
+    this.onClose?.(event);
+  }
+
+  async send(data: string) {
+    this.throwIfNotOpen();
+
+    await new Promise((resolve, reject) => {
+      this.socket!.send(data, (error) => {
+        error ? reject(error) : resolve(undefined);
+      });
+    });
+  }
+
+  private throwIfNotOpen() {
+    if (!this.socket) {
+      throw new Error('Client is not connected');
+    }
+
+    const { readyState, OPEN } = this.socket;
+    if (readyState === OPEN) return;
+    if (readyState < OPEN) {
+      throw new Error('socket is still connecting');
+    }
+    if (readyState > OPEN) {
+      throw new Error('socket was closed');
+    }
+  }
+}

package/src/content-elements/index.ts

@@ -0,0 +1,113 @@
+import { Alignment, AnImage } from '../types/story';
+
+export type ContentElementType<T extends keyof typeof ContentElement> = ReturnType<(typeof ContentElement)[T]>;
+
+const refType = 'reference' as const;
+
+export const ContentElement = {
+  divider: () => {
+    return {
+      type: 'divider' as const,
+    };
+  },
+  text: (content: string, alignment: Alignment = 'left') => {
+    return {
+      type: 'text' as const,
+      content,
+      alignment,
+    };
+  },
+  quote: (content: string) => {
+    return {
+      type: 'quote' as const,
+      subtype: 'pullquote' as const,
+      citation: {
+        type: 'text' as const,
+        content: '',
+      },
+      content_elements: [
+        {
+          content,
+          type: 'text' as const,
+        },
+      ],
+    };
+  },
+  interstitial_link: (url: string, content: string) => {
+    return {
+      type: 'interstitial_link' as const,
+      url,
+      content,
+    };
+  },
+  header: (content: string, level: number) => {
+    return {
+      type: 'header' as const,
+      content,
+      level,
+    };
+  },
+  raw_html: (content: string) => {
+    return {
+      type: 'raw_html' as const,
+      content,
+    };
+  },
+  gallery: (id: string) => {
+    return {
+      type: refType,
+      referent: {
+        type: 'gallery' as const,
+        id,
+      },
+    };
+  },
+  list: (type: 'ordered' | 'unordered', items: string[]) => {
+    return {
+      type: 'list' as const,
+      list_type: type,
+      items: items.map((content) => {
+        return {
+          type: 'text' as const,
+          content,
+        };
+      }),
+    };
+  },
+  link_list: (title: string, links: { content: string; url: string }[]) => {
+    return {
+      type: 'link_list' as const,
+      title,
+      items: links.map(({ content, url }) => {
+        return {
+          type: 'interstitial_link' as const,
+          content,
+          url,
+        };
+      }),
+    };
+  },
+  image: (id: string, properties: AnImage) => {
+    return {
+      referent: {
+        id,
+        type: 'image' as const,
+        referent_properties: {
+          ...properties,
+        },
+      },
+      type: refType,
+    };
+  },
+  jwPlayer: (id: string) => {
+    return {
+      embed: {
+        config: {},
+        id,
+        url: 'https://cdn.jwplayer.com/players',
+      },
+      subtype: 'jw_player' as const,
+      type: 'custom_embed' as const,
+    };
+  },
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+import { ArcAPI } from './api';
+import { ContentElement, ContentElementType } from './content-elements';
+import * as ArcTypes from './types';
+
+export { ArcAPI, ContentElement, ContentElementType, ArcTypes };

package/src/tests/api/basic.test.ts

@@ -0,0 +1,17 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { ArcAPI } from '../../api';
+
+describe('Arc API', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.clearAllMocks();
+  });
+
+  test('should throw error (Invalid token)', async () => {
+    const Arc = ArcAPI({ credentials: { organizationName: 'codestore', accessToken: Date.now().toString() } });
+
+    await expect(Arc.api.Draft.generateId(Date.now().toString())).rejects.toThrowError(
+      'Request failed with status code 401'
+    );
+  });
+});