@stackbit/cms-contentstack 0.1.1-staging.0

package/src/contentstack-content-poller.ts

@@ -0,0 +1,157 @@
+import _ from 'lodash';
+import type { Logger } from '@stackbit/types';
+import type { ContentStackClient } from './contentstack-api-client';
+import type { ContentType, GlobalField, Entry, Asset } from './contentstack-types';
+
+export type SyncContext = {
+    lastUpdatedEntryDate?: string;
+    lastUpdatedAssetDate?: string;
+    lastUpdatedContentTypeDate?: string;
+    lastUpdatedGlobalFieldDate?: string;
+};
+
+export interface SyncResult {
+    entries: Entry[];
+    assets: Asset[];
+    contentTypes: ContentType[];
+    globalFields: GlobalField[];
+    deletedEntries: Entry[];
+    deletedAssets: Asset[];
+}
+
+export type SyncCallback = (result: SyncResult) => void;
+
+export class ContentPoller {
+    private readonly logger: Logger;
+    private readonly contentStackClient: ContentStackClient;
+    private readonly notificationCallback: SyncCallback;
+    private readonly pollingIntervalMs: number;
+    private readonly modelNames: string[];
+    private running: boolean;
+    private pollTimeout: NodeJS.Timeout | null;
+    private syncContext!: Required<SyncContext>;
+
+    constructor({
+        modelNames,
+        contentStackClient,
+        syncContext,
+        pollingIntervalMs = 2000,
+        notificationCallback,
+        logger
+    }: {
+        modelNames: string[];
+        contentStackClient: ContentStackClient;
+        syncContext?: SyncContext;
+        pollingIntervalMs?: number;
+        notificationCallback: SyncCallback;
+        logger: Logger;
+    }) {
+        this.logger = logger;
+        this.modelNames = modelNames;
+        this.running = false;
+        this.pollTimeout = null;
+        this.pollingIntervalMs = pollingIntervalMs;
+        this.contentStackClient = contentStackClient;
+        this.notificationCallback = notificationCallback;
+        this.setSyncContext(syncContext);
+        this.handleTimeout = this.handleTimeout.bind(this);
+    }
+
+    start() {
+        this.logger.debug(`start polling Contentstack for content changes`);
+        if (!this.running) {
+            this.running = true;
+            this.setPollTimeout();
+        }
+    }
+
+    stop() {
+        this.logger.debug(`stop polling Contentstack for content changes`);
+        if (this.pollTimeout) {
+            clearTimeout(this.pollTimeout);
+            this.pollTimeout = null;
+        }
+        this.running = false;
+    }
+
+    setSyncContext(syncContext?: SyncContext) {
+        const now = new Date().toISOString();
+        this.syncContext = {
+            lastUpdatedEntryDate: syncContext?.lastUpdatedEntryDate ?? now,
+            lastUpdatedAssetDate: syncContext?.lastUpdatedAssetDate ?? now,
+            lastUpdatedContentTypeDate: syncContext?.lastUpdatedContentTypeDate ?? now,
+            lastUpdatedGlobalFieldDate: syncContext?.lastUpdatedGlobalFieldDate ?? now
+        };
+    }
+
+    private setPollTimeout() {
+        if (this.pollTimeout) {
+            clearTimeout(this.pollTimeout);
+        }
+        this.pollTimeout = setTimeout(this.handleTimeout, this.pollingIntervalMs);
+    }
+
+    async handleTimeout() {
+        this.pollTimeout = null;
+        try {
+            await this.pollContent();
+        } catch (error: any) {
+            this.logger.warn('error polling', { error: error.message });
+        }
+        if (this.running) {
+            this.setPollTimeout();
+        }
+    }
+
+    async pollContent(): Promise<any> {
+        const prevSyncContext = this.syncContext;
+        const [entries, assets, contentTypes, globalFields] = await Promise.all([
+            this.contentStackClient.getAllEntriesUpdatedAfter(this.modelNames, this.syncContext.lastUpdatedEntryDate),
+            this.contentStackClient.getAssetsUpdatedAfter(this.syncContext.lastUpdatedAssetDate),
+            this.contentStackClient.getContentTypesUpdatedAfter(this.syncContext.lastUpdatedContentTypeDate),
+            this.contentStackClient.getGlobalFieldsUpdatedAfter(this.syncContext.lastUpdatedGlobalFieldDate)
+        ]);
+        // Check that syncContext wasn't updated externally by calling
+        // setLastUpdatedAt() while the content is being fetched. If it was
+        // updated, then ignore the dates from the fetched content and use the
+        // syncContext that was set externally in the next poll.
+        if (_.isEqual(prevSyncContext, this.syncContext)) {
+            this.syncContext = _.defaults(
+                {
+                    lastUpdatedEntryDate: getLastUpdatedEntityDate(entries),
+                    lastUpdatedAssetDate: getLastUpdatedEntityDate(assets),
+                    lastUpdatedContentTypeDate: getLastUpdatedEntityDate(contentTypes),
+                    lastUpdatedGlobalFieldDate: getLastUpdatedEntityDate(globalFields)
+                },
+                this.syncContext
+            );
+        }
+        if (contentTypes.length || globalFields.length || entries.length || assets.length) {
+            this.logger.info(
+                `poll date response: got ` +
+                    `${entries.length} changed entries, ` +
+                    `${assets.length} changed assets, ` +
+                    `${contentTypes.length} changed content types` +
+                    `${globalFields.length} changed global fields`
+            );
+            this.notificationCallback({
+                contentTypes,
+                globalFields,
+                entries,
+                assets,
+                deletedEntries: [],
+                deletedAssets: []
+            });
+        }
+    }
+}
+
+export function getLastUpdatedEntityDate(entities: { updated_at?: string }[]): string | undefined {
+    let lastUpdatedDate: string = '';
+    for (const entity of entities) {
+        if (entity.updated_at! > lastUpdatedDate) {
+            lastUpdatedDate = entity.updated_at!;
+        }
+    }
+    return lastUpdatedDate || undefined;
+}