fix mappers

Author: msadovyi

CHANGELOG.md

@@ -1,5 +1,11 @@
 # @code.store/arcxp-sdk-ts
 
+## 4.34.1
+
+### Patch Changes
+
+- fix mapper types and methods
+
 ## 4.34.0
 
 ### Minor Changes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code.store/arcxp-sdk-ts",
-  "version": "4.34.0",
+  "version": "4.34.1",
   "description": "A strongly typed set of ArcXP API's and utilities reduce the amount of work required to develop with ArcXP, starting with reducing the boilerplate code you have to write.",
   "type": "commonjs",
   "main": "./dist/index.js",

src/ans/image.ts

@@ -1,11 +1,4 @@
-import { ArcAPI, ArcAPIType } from './api';
-import { ArcError } from './api/error';
-import { WsClient } from './api/ws.client';
-import { ContentElement, ContentElementType } from './content-elements';
-import * as ArcTypes from './types';
-import { ArcUtils } from './utils/arc';
-import * as ArcAns from './ans';
-
+export * as ArcTypes from './types';
 export * from './api/identity/types';
 export * from './api/draft/types';
 export * from './api/site/types';
@@ -20,4 +13,9 @@ export * from './api/global-settings/types';
 export * from './api/tags/types';
 export * from './api/content-ops/types';
 
-export { ArcAPI, ArcAPIType, ArcUtils, WsClient, ContentElement, ContentElementType, ArcTypes, ArcError, ArcAns };
+export { ArcAPI, ArcAPIType } from './api';
+export { ArcUtils } from './utils/arc';
+export { ArcError } from './api/error';
+export { WsClient } from './api/ws.client';
+export { ContentElement, ContentElementType } from './content-elements';
+export * as AnsMapper from './mapper';

src/ans/index.ts

@@ -12,27 +12,26 @@ import type { MaybePromise, Optional } from '../types/utils';
  *
  * To migrate it call .migrate() method
  */
-export abstract class ArcDocument<ANS extends ANSContent> {
+export abstract class Document<ANS extends ANSContent> {
   public ans: ANS | null = null;
   public circulations: CirculationReference[] = [];
 
   async init(): Promise<void> {
     // fetch necessary data and validate it here
   }
 
-  abstract get sourceId(): string;
-  abstract get sourceType(): string;
-  abstract get websiteId(): string;
-  abstract get legacyUrl(): string;
-  abstract get arcId(): string;
-  abstract get type(): string;
-  abstract get groupId(): string;
-  abstract get version(): ArcTypes.Story.DescribesTheANSVersionOfThisObject;
+  abstract sourceId(): MaybePromise<string>;
+  abstract sourceType(): MaybePromise<string>;
+  abstract websiteId(): MaybePromise<string>;
+  abstract legacyUrl(): MaybePromise<string>;
+  abstract arcId(): MaybePromise<string>;
+  abstract type(): MaybePromise<string>;
+  abstract groupId(): MaybePromise<string>;
+  abstract version(): ArcTypes.Story.DescribesTheANSVersionOfThisObject;
 
   abstract getAns(): MaybePromise<ANS>;
-  abstract post(params: PostANSParams, payload: PostANSPayload): Promise<void>;
 
-  async migrate(): Promise<{
+  async prepare(): Promise<{
     params: PostANSParams;
     payload: PostANSPayload<ANS>;
   }> {
@@ -41,8 +40,6 @@ export abstract class ArcDocument<ANS extends ANSContent> {
     const payload = await this.payload();
     const params = await this.params();
 
-    await this.post(params, payload);
-
     return { payload, params };
   }
 
@@ -51,35 +48,35 @@ export abstract class ArcDocument<ANS extends ANSContent> {
     this.circulations = await this.getCirculations();
 
     return {
-      sourceId: this.sourceId,
-      sourceType: this.sourceType,
+      sourceId: await this.sourceId(),
+      sourceType: await this.sourceType(),
       ANS: this.ans,
       circulations: this.circulations,
-      arcAdditionalProperties: this.additionalProperties,
+      arcAdditionalProperties: this.additionalProperties(),
     };
   }
 
   private async params(): Promise<PostANSParams> {
-    if (!this.websiteId) {
+    if (!this.websiteId()) {
       throw new Error('Website is not initialized! get params() should be called after payload()!');
     }
 
     return {
-      website: this.websiteId,
-      groupId: this.groupId,
-      priority: this.priority,
+      website: await this.websiteId(),
+      groupId: await this.groupId(),
+      priority: this.priority(),
     };
   }
 
-  protected get additionalProperties(): PostANSPayload['arcAdditionalProperties'] {
+  protected additionalProperties(): PostANSPayload['arcAdditionalProperties'] {
     return {
       story: {
         publish: false,
       },
     };
   }
 
-  protected get priority(): 'historical' | 'live' {
+  protected priority(): 'historical' | 'live' {
     return 'historical';
   }
 
@@ -95,11 +92,11 @@ export abstract class ArcDocument<ANS extends ANSContent> {
     return;
   }
 
-  protected getSource(): Optional<ArcTypes.Story.Source> {
+  protected async getSource(): Promise<Optional<ArcTypes.Story.Source>> {
     return {
       name: 'code-store',
       system: 'code-store',
-      source_id: this.sourceId,
+      source_id: await this.sourceId(),
     };
   }
 

src/index.ts

@@ -0,0 +1,2 @@
+export { Document } from './doc';
+export { Story } from './story';

src/ans/doc.ts src/mapper/doc.tssrc/ans/doc.ts renamed to src/mapper/doc.ts

@@ -1,5 +1,6 @@
-import type { Story } from '../types';
-import { ArcDocument } from './doc';
+import type { ANSContent } from '../api/migration-center/types';
+import type * as Types from '../types';
+import { Document } from './doc';
 
 /**
  * Base class for all arc stories, it provides common methods and properties
@@ -18,11 +19,15 @@ import { ArcDocument } from './doc';
  *     }];
  * }
  */
-export abstract class ArcStory extends ArcDocument<Story.AStory> {
-  type = 'story' as const;
+export abstract class Story<ANS extends ANSContent = Types.Story.AStory> extends Document<ANS> {
+  type() {
+    return 'story' as const;
+  }
 
   async getAns() {
-    const id = this.arcId;
+    const id = await this.arcId();
+    const version = this.version();
+    const type = this.type();
     const publicationDate = this.getPublicationDate();
     const headlines = this.getHeadlines();
     const subheadlines = this.getSubheadlines();
@@ -38,13 +43,17 @@ export abstract class ArcStory extends ArcDocument<Story.AStory> {
     const promoItems = await this.getPromoItems();
     const contentElements = await this.getContentElements();
     const webskedStatusCode = await this.getWebskedStatusCode();
+    const websiteId = await this.websiteId();
+    const source = await this.getSource();
+    const comments = await this.getComments();
+    const legacyUrl = await this.legacyUrl();
 
     return {
-      type: this.type,
+      type,
       _id: id,
-      version: this.version,
-      website: this.websiteId,
-      canonical_website: this.websiteId,
+      version,
+      website: websiteId,
+      canonical_website: websiteId,
       language,
       subtype,
       label,
@@ -62,8 +71,8 @@ export abstract class ArcStory extends ArcDocument<Story.AStory> {
       first_publish_date: this.formatDate(publicationDate),
       publish_date: this.formatDate(publicationDate),
       display_date: this.formatDate(this.getDisplayDate()),
-      source: this.getSource(),
-      comments: this.getComments(),
+      source,
+      comments,
       taxonomy: {
         tags,
       },
@@ -72,8 +81,8 @@ export abstract class ArcStory extends ArcDocument<Story.AStory> {
       },
       content_elements: contentElements,
       additional_properties: {
-        url: this.legacyUrl,
+        url: legacyUrl,
       },
-    };
+    } as unknown as ANS;
   }
 }

src/mapper/index.ts

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { ContentElement } from '../../content-elements';
+import { Story } from '../../mapper';
+
+describe('Mapper', () => {
+  const ans = {
+    type: 'story',
+    _id: 'arc_id',
+    version: '1.0.0',
+    website: 'website_id',
+    canonical_website: 'website_id',
+    language: 'en-GB',
+    subtype: 'subtype',
+    credits: { by: [] },
+    headlines: { basic: '' },
+    subheadlines: { basic: '' },
+    description: { basic: '' },
+    created_date: expect.any(String),
+    first_publish_date: expect.any(String),
+    publish_date: expect.any(String),
+    display_date: expect.any(String),
+    source: { name: 'code-store', system: 'code-store', source_id: 'source_id' },
+    taxonomy: { tags: [] },
+    workflow: expect.any(Object),
+    content_elements: [{ type: 'text', content: '', alignment: 'left' }],
+    additional_properties: { url: 'legacy_url' },
+  };
+
+  const mocks = {
+    init: vi.fn().mockResolvedValue(undefined),
+    getSourceId: vi.fn().mockResolvedValue('source_id'),
+    getSourceType: vi.fn().mockResolvedValue('source_type'),
+    getWebsiteId: vi.fn().mockResolvedValue('website_id'),
+    getLegacyUrl: vi.fn().mockResolvedValue('legacy_url'),
+    getArcId: vi.fn().mockResolvedValue('arc_id'),
+    getGroupId: vi.fn().mockResolvedValue('group_id'),
+    getSubtype: vi.fn().mockResolvedValue('subtype'),
+    getContentElements: vi.fn().mockResolvedValue([ContentElement.text('')]),
+  };
+
+  class CodeStory extends Story {
+    version = () => '1.0.0' as any;
+    groupId = mocks.getGroupId;
+    sourceId = mocks.getSourceId;
+    sourceType = mocks.getSourceType;
+    websiteId = mocks.getWebsiteId;
+    legacyUrl = mocks.getLegacyUrl;
+    arcId = mocks.getArcId;
+
+    init = mocks.init;
+    getSubtype = mocks.getSubtype;
+    getContentElements = mocks.getContentElements;
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('Should return valid ANS', async () => {
+    const story = new CodeStory();
+
+    const ans = await story.getAns();
+
+    expect(ans).toBeDefined();
+    expect(ans.type).toBe('story');
+    expect(ans._id).toBe('arc_id');
+    expect(ans.version).toBe('1.0.0');
+  });
+
+  test('prepare() should call params, payload, getAns', async () => {
+    const story = new CodeStory();
+    const getAns = vi.spyOn(story, 'getAns');
+    const payload = vi.spyOn(story, 'payload' as any);
+    const params = vi.spyOn(story, 'params' as any);
+    const result = await story.prepare();
+
+    expect(mocks.init).toBeCalledTimes(1);
+    expect(getAns).toBeCalledTimes(1);
+    expect(payload).toBeCalledTimes(1);
+    expect(params).toBeCalledTimes(1);
+    expect(mocks.getContentElements).toBeCalledTimes(1);
+
+    expect(result.params).toBeDefined();
+    expect(result.params.website).toBe('website_id');
+    expect(result.params.groupId).toBe('group_id');
+    expect(result.params.priority).toBe('historical');
+
+    expect(result.payload).toBeDefined();
+    expect(result.payload.sourceId).toBe('source_id');
+    expect(result.payload.sourceType).toBe('source_type');
+    expect(result.payload.ANS).toMatchObject(ans);
+  });
+});