@code.store/arcxp-sdk-ts 1.0.0

package/.eslintrc.js

@@ -0,0 +1,26 @@
+module.exports = {
+  root: true,
+  extends: [
+    'custom-server',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:@typescript-eslint/recommended-requiring-type-checking',
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  rules: {
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    '@typescript-eslint/no-floating-promises': 'off',
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-argument': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-non-null-asserted-optional-chain': 'off',
+    '@typescript-eslint/restrict-template-expressions': 'off',
+  },
+  parserOptions: {
+    project: './tsconfig.json',
+  },
+  ignorePatterns: ['.eslintrc.js', 'vite.config.ts', 'scripts/*.js'],
+};

package/.github/workflows/build-test-lint.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: ['main']
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  build:
+    name: Build & Test
+    timeout-minutes: 5
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 2
+
+      - uses: pnpm/action-setup@v2.0.1
+        with:
+          version: 7.22.0
+
+      - name: Setup Node.js environment
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.12.1
+          cache: 'pnpm'
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Lint
+        run: pnpm lint
+
+      - name: Test
+        run: pnpm test

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 120,
+  "arrowParens": "always"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 code.store
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# arcxp-sdk-ts
+TypeScript SDK for ArcXP

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@code.store/arcxp-sdk-ts",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.ts",
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit && TIMING=1 eslint \"src/**/*.ts*\"",
+    "start": "dotenv -e .env -- node ./dist/server.js",
+    "test": "vitest",
+    "publish": "node ./scripts/publish"
+  },
+  "keywords": [],
+  "author": "code.store",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "axios-rate-limit": "^1.3.0",
+    "form-data": "^4.0.0",
+    "typescript": "^4.9.4",
+    "ws": "^8.14.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.14.6",
+    "@types/tap": "^15.0.8",
+    "@types/ws": "^8.5.5",
+    "@typescript-eslint/eslint-plugin": "^5.47.1",
+    "@typescript-eslint/parser": "^5.47.1",
+    "eslint": "^8.31.0",
+    "eslint-config-custom-server": "*",
+    "openapi-typescript": "^6.2.7",
+    "tap": "^16.3.4",
+    "ts-node-dev": "^2.0.0",
+    "vitest": "^0.33.0"
+  }
+}

package/scripts/publish.js

@@ -0,0 +1,24 @@
+const { exec } = require('child_process');
+
+const packageJson = require('../package.json');
+const packageName = packageJson.name;
+const packageVersion = packageJson.version;
+const optCode = '947810';
+
+// Publish the package
+function publish() {
+  console.log(`Publishing ${packageName}@${packageVersion}...`);
+
+  const publishProcess = exec(`npm publish --access public --otp=${optCode}`, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`Error publishing ${packageName}@${packageVersion}: ${error.message}`);
+    } else {
+      console.log(`Successfully published ${packageName}@${packageVersion}`);
+    }
+  });
+
+  publishProcess.stdout.pipe(process.stdout);
+  publishProcess.stderr.pipe(process.stderr);
+}
+
+publish();

package/src/api/abstract-api.ts

@@ -0,0 +1,42 @@
+import axios from 'axios';
+import { AxiosResponseErrorInterceptor } from '../utils';
+import rateLimit, { RateLimitedAxiosInstance } from 'axios-rate-limit';
+import { ArcError } from './error';
+
+export type ArcAbstractAPIOptions = {
+  credentials: { organizationName: string; accessToken: string };
+  apiPath: string;
+  maxRPS?: number;
+};
+
+export type ArcAPIOptions = Omit<ArcAbstractAPIOptions, 'apiPath'>;
+
+export abstract class ArcAbstractAPI {
+  protected name = this.constructor.name;
+  protected client: RateLimitedAxiosInstance;
+
+  private token = '';
+  private host = '';
+  private headers = {
+    Authorization: '',
+  };
+
+  constructor(options: ArcAbstractAPIOptions) {
+    this.host = `api.${options.credentials.organizationName}.arcpublishing.com`;
+    this.token = `Bearer ${options.credentials.accessToken}`;
+    this.headers.Authorization = this.token;
+    this.client = rateLimit(
+      axios.create({
+        baseURL: `https://${this.host}/${options.apiPath}`,
+        headers: this.headers,
+      }),
+      { maxRPS: options.maxRPS || 10 }
+    );
+
+    this.client.interceptors.response.use(...AxiosResponseErrorInterceptor((e) => new ArcError(this.name, e)));
+  }
+
+  setMaxRPS(rps: number) {
+    this.client.setMaxRPS(rps);
+  }
+}

package/src/api/author/index.ts

@@ -0,0 +1,13 @@
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+
+export class ArcAuthor extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'author' });
+  }
+
+  async delete(userId: string): Promise<void> {
+    const { data } = await this.client.delete(`/v2/author-service/${userId}`);
+
+    return data;
+  }
+}

package/src/api/draft/index.ts

@@ -0,0 +1,13 @@
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+
+export class ArcDraft extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'draft/v1' });
+  }
+
+  async generateId(id: string) {
+    const { data } = await this.client.get<{ id: string }>('/arcuuid', { params: { id } });
+  
+    return data.id;
+  }
+}

package/src/api/error.ts

@@ -0,0 +1,27 @@
+import { AxiosError, InternalAxiosRequestConfig } from 'axios';
+import { safeJSONStringify } from '../utils';
+
+export class ArcError extends Error {
+  public responseData: unknown;
+  public responseStatus?: number;
+  public responseConfig?: InternalAxiosRequestConfig<any>;
+  public ratelimitRemaining?: string;
+  public ratelimitReset?: string;
+  public service?: string;
+
+  constructor(service: string, e: AxiosError) {
+    const ratelimitRemaining = e.response?.headers['arcpub-ratelimit-remaining'];
+    const ratelimitReset = e.response?.headers['arcpub-ratelimit-reset'];
+    const message = safeJSONStringify(e.message);
+
+    super(message);
+
+    this.name = `${service}Error`;
+    this.responseData = e.response?.data;
+    this.responseStatus = e.response?.status;
+    this.responseConfig = e.response?.config;
+    this.ratelimitRemaining = ratelimitRemaining;
+    this.ratelimitReset = ratelimitReset;
+    this.service = service;
+  }
+}

package/src/api/identity/index.ts

@@ -0,0 +1,14 @@
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+import { MigrateBatchUsersPayload, MigrateBatchUsersResponse } from './types';
+
+export class ArcIdentity extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'identity/api/v1' });
+  }
+
+  async migrateBatch(payload: MigrateBatchUsersPayload) {
+    const { data } = await this.client.post<MigrateBatchUsersResponse>('/migrate', payload);
+
+    return data;
+  }
+}

package/src/api/identity/types.ts

@@ -0,0 +1,61 @@
+export type MigrateIdentityCustomAttributeType = {
+  name: string;
+  value: string;
+  type: 'String' | 'Number' | 'Date' | 'Boolean';
+};
+
+export type MigrateUserPayload = {
+  identities: {
+    userName: string;
+    credentials: string;
+    grantType: 'password';
+    lastLoginDate?: string;
+  }[];
+  profile: {
+    firstName: string;
+    lastName: string;
+    secondLastName?: string;
+    displayName: string;
+    gender?: 'MALE' | 'FEMALE';
+    email: string;
+    birthYear: string;
+    birthMonth: string;
+    birthDay: string;
+    contacts: {
+      phone: string;
+      type: 'WORK' | 'HOME' | 'PRIMARY' | 'OTHER';
+    }[];
+    addresses: {
+      line1: string;
+      line2?: string;
+      locality: string;
+      region?: string;
+      postal: string;
+      country?: string;
+      type: 'WORK' | 'HOME' | 'PRIMARY' | 'OTHER';
+    }[];
+    attributes: MigrateIdentityCustomAttributeType[];
+    legacyId: string;
+    deletionRule?: 1;
+    emailVerified?: boolean;
+    createdOn: string;
+  };
+  uuid?: string;
+};
+
+export type MigrateBatchUsersPayload = {
+  records: MigrateUserPayload[];
+};
+
+export type MigrateBatchUsersResponse = {
+  records: {
+    email: string;
+    success: boolean;
+    errorMessage: string;
+    result: 'CREATE' | 'UPDATE';
+    uuid: string;
+  }[];
+  time: number;
+  errorCount: number;
+  successCount: number;
+};

package/src/api/ifx/index.ts

@@ -0,0 +1,64 @@
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+import { AddSecretPayload, CreateIntegrationPayload, SubscribePayload, UpdateIntegrationPayload } from './types';
+
+export class ArcIFX extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'ifx/api/v1' });
+  }
+
+  async createIntegration(payload: CreateIntegrationPayload) {
+    await this.client.post('/admin/integration', payload);
+  }
+
+  async updateIntegration(payload: UpdateIntegrationPayload) {
+    await this.client.put('/admin/integration', payload);
+  }
+
+  async getIntegrations() {
+    const { data } = await this.client.get('/admin/integrations');
+    return data;
+  }
+
+  async getJobs(integrationName: string) {
+    const { data } = await this.client.get(`/admin/jobs/status/${integrationName}`);
+    return data;
+  }
+
+  async getStatus(integrationName: string) {
+    const { data } = await this.client.get(`/admin/integration/${integrationName}/provisionStatus`);
+    return data;
+  }
+
+  async initializeQuery(integrationName: string, query?: string) {
+    const { data } = await this.client.get<{ queryId: string }>(`/admin/logs/integration/${integrationName}?${query}`);
+    return data;
+  }
+
+  async getLogs(queryId: string) {
+    const { data } = await this.client.get(`/admin/logs/results?queryId=${queryId}`);
+    return data;
+  }
+
+  async subscribe(payload: SubscribePayload) {
+    const { data } = await this.client.post('/admin/events/subscriptions', payload);
+    return data;
+  }
+
+  async getSubscriptions() {
+    const { data } = await this.client.get('/admin/events/subscriptions');
+    return data;
+  }
+
+  async addSecret(payload: AddSecretPayload) {
+    const { data } = await this.client.post(`/admin/secret?integrationName=${payload.intergrationName}`, {
+      secretName: payload.secretName,
+      secretValue: payload.secretValue,
+    });
+    return data;
+  }
+
+  async getSecrets(integrationName: string) {
+    const { data } = await this.client.get(`/admin/secret?integrationName=${integrationName}`);
+    return data;
+  }
+}

package/src/api/ifx/types.ts

@@ -0,0 +1,27 @@
+export type CreateIntegrationPayload = {
+  integrationName: string;
+  description: string;
+  email: string;
+  provisionPAT: boolean;
+  githubUsernames: string[];
+  runtime: 'node';
+};
+
+export type UpdateIntegrationPayload = {
+  integrationName: string;
+  enabled: boolean;
+  githubUsernames: string[];
+  githubUserAction: 'add' | 'replace';
+};
+
+export type SubscribePayload = {
+  eventName: string;
+  integrationName: string;
+  enabled: boolean;
+};
+
+export type AddSecretPayload = {
+  intergrationName: string;
+  secretName: string;
+  secretValue: string;
+};

package/src/api/index.ts

@@ -0,0 +1,35 @@
+import { ArcAPIOptions } from './abstract-api';
+import { ArcAuthor } from './author';
+import { ArcDraft } from './draft';
+import { ArcIdentity } from './identity';
+import { ArcIFX } from './ifx';
+import { ArcMigrationCenter } from './migration-center';
+import { ArcSales } from './sales';
+import { ArcSite } from './site';
+import WsClient from './ws.client';
+
+export const ArcAPI = (options: ArcAPIOptions) => {
+  const api = {
+    Author: new ArcAuthor(options),
+    Draft: new ArcDraft(options),
+    Identity: new ArcIdentity(options),
+    IFX: new ArcIFX(options),
+    MigrationCenter: new ArcMigrationCenter(options),
+    Sales: new ArcSales(options),
+    Site: new ArcSite(options),
+  };
+
+  return {
+    api,
+    RetailEvents: (index: '0' | '1' | 'string' = '0') => {
+      const address = `wss://api.${options.credentials.organizationName}.arcpublishing.com/retail/api/v1/event/stream/${index}`;
+      const headers = {
+        Authorization: `Bearer ${options.credentials.accessToken}`,
+      };
+      return new WsClient(address, { headers });
+    },
+    setMaxRPS: (rps: number) => {
+      Object.values(api).forEach((a) => a.setMaxRPS(rps));
+    },
+  };
+};

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

@@ -0,0 +1,47 @@
+import {
+  PostANSParams,
+  PostANSPayload,
+  GetANSParams,
+  Summary,
+  Count,
+  DetailReportRequest,
+  SummaryReportRequest,
+  DetailReport,
+} from './types';
+import { ArcAbstractAPI, ArcAPIOptions } from '../abstract-api';
+import { stringify } from 'querystring';
+
+export class ArcMigrationCenter extends ArcAbstractAPI {
+  constructor(options: ArcAPIOptions) {
+    super({ ...options, apiPath: 'migrations/v3' });
+  }
+
+  async summary(params?: SummaryReportRequest) {
+    const { data } = await this.client.get<Summary>(`/report/summary?${stringify(params)}`);
+    return data;
+  }
+
+  async detailed(params?: DetailReportRequest) {
+    const { data } = await this.client.get<DetailReport>(`/report/detail?${stringify(params)}`);
+    return data;
+  }
+
+  async count() {
+    const { data } = await this.client.get<Count>('/report/status/count');
+    return data;
+  }
+
+  async postAns(params: PostANSParams, payload: PostANSPayload) {
+    const search = new URLSearchParams(params).toString();
+
+    const { data } = await this.client.post(`/content/ans?${search}`, payload);
+    return data;
+  }
+
+  async getAns(params: GetANSParams) {
+    const search = new URLSearchParams(params).toString();
+
+    const { data } = await this.client.get(`/content/ans?${search}`);
+    return data;
+  }
+}