@stackbit/cms-contentstack 0.1.1-staging.0

package/src/contentstack-content-source.ts

@@ -0,0 +1,687 @@
+import { unlink, writeFile } from 'fs/promises';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import _ from 'lodash';
+import * as StackbitTypes from '@stackbit/types';
+import { getVersion as getStackbitInterfaceVersion } from '@stackbit/types';
+import { ContentStackClient } from './contentstack-api-client';
+import { convertLocales, convertModels, ModelContext, ModelWithContext } from './contentstack-schema-converter';
+import {
+    DocumentContext,
+    AssetContext,
+    convertEntry,
+    convertEntries,
+    convertAsset,
+    convertAssets,
+    DocumentWithContext
+} from './contentstack-entries-converter';
+import { createEntryFromOperationFields, updateEntryFromUpdateOperations } from './contentstack-operation-converter';
+import { getContentstackDashboardUrl, resolvePublishEnvironment, downloadFile, createWebhookIfNeeded, userMissingInMap } from './contentstack-utils';
+import { ContentPoller, getLastUpdatedEntityDate, SyncContext, SyncResult } from './contentstack-content-poller';
+import type { User, Asset, Entry, Environment, WebhookPayload } from './contentstack-types';
+
+type UserWithContext = StackbitTypes.User<UserContext>;
+type UserContext = unknown;
+type SchemaContext = unknown;
+
+export interface ContentStackSourceOptions {
+    apiKey: string;
+    managementToken: string;
+    branch?: string;
+    /**
+     * User specific authtoken. You should use an authtoken of a "service" user
+     * of your organization. If you don't pass the authtoken, some features
+     * may not work in Stackbit properly.
+     *
+     * To get the authtoken, use the following command:
+     * ```
+     * curl -X POST \
+     *      -H "Content-Type: application/json" \
+     *      -d '{"user":{"email":"simon@stackbit.com","password":"i7rdEiZUt!6tMEUkeFTo"}}' \
+     *      https://api.contentstack.io/v3/user-session \
+     *      | grep -ioE '"authtoken":"([^\"])+"'
+     * ```
+     */
+    authtoken?: string;
+    /**
+     * The master locale of the Stack. If `authtoken` is provided, then there is
+     * no need to pass `masterLocale` as it will be fetched from the stack API.
+     */
+    masterLocale?: string;
+    /**
+     * Environment for publishing entries. If your Contentstack has multiple
+     * environments this property need to be specified.
+     */
+    publishEnvironmentName?: string;
+    /**
+     * Do not fetch documents and assets when content source starts if there are
+     * cached documents and assets. The newer document and asset versions will
+     * be fetched by polling content. This flag is applicable only when running
+     * `stackbit dev` locally without webhooks, i.e., --csi-webhook-url is not
+     * provided.
+     */
+    skipFetchOnStartIfCache?: boolean;
+}
+
+export type CacheWithContext = StackbitTypes.Cache<SchemaContext, DocumentContext, AssetContext, ModelContext>;
+
+export class ContentstackContentSource
+    implements StackbitTypes.ContentSourceInterface<UserContext, SchemaContext, DocumentContext, AssetContext, ModelContext>
+{
+    private readonly apiKey: string;
+    private readonly managementToken: string;
+    private readonly branch?: string;
+    private readonly authtoken?: string;
+    private masterLocale?: string;
+    private contentStackClient!: ContentStackClient;
+    private logger!: StackbitTypes.Logger;
+    private userLogger!: StackbitTypes.Logger;
+    private cache!: CacheWithContext;
+    private useContentPoller: boolean = false;
+    private contentPoller: ContentPoller | null = null;
+    private syncContext!: SyncContext;
+    private skipFetchOnStartIfCache: boolean = false;
+    private updateCacheOnFirstPoll: boolean = false;
+    private publishEnvironmentName?: string;
+    private publishEnvironment!: Environment;
+    private usersById: Record<string, User> = {};
+
+    constructor({ apiKey, managementToken, branch, authtoken, masterLocale, publishEnvironmentName, skipFetchOnStartIfCache }: ContentStackSourceOptions) {
+        this.apiKey = apiKey;
+        this.managementToken = managementToken;
+        this.branch = branch;
+        this.authtoken = authtoken;
+        this.masterLocale = masterLocale;
+        this.publishEnvironmentName = publishEnvironmentName;
+        if (skipFetchOnStartIfCache) {
+            this.skipFetchOnStartIfCache = true;
+            this.updateCacheOnFirstPoll = true;
+        }
+    }
+
+    async getVersion(): Promise<StackbitTypes.Version> {
+        return getStackbitInterfaceVersion({ packageJsonPath: path.join(__dirname, '../package.json') });
+    }
+
+    getContentSourceType(): string {
+        return 'contentstack';
+    }
+
+    getProjectId(): string {
+        return this.apiKey;
+    }
+
+    getProjectEnvironment(): string {
+        return this.branch ?? 'main';
+    }
+
+    getProjectManageUrl(): string {
+        return getContentstackDashboardUrl({ apiKey: this.apiKey, branch: this.branch });
+    }
+
+    async init({
+        localDev,
+        logger,
+        userLogger,
+        webhookUrl,
+        cache
+    }: StackbitTypes.InitOptions<SchemaContext, DocumentContext, AssetContext, ModelContext>): Promise<void> {
+        this.logger = logger.createLogger({ label: 'contentstack' });
+        this.userLogger = userLogger.createLogger({ label: 'contentstack' });
+        this.cache = cache;
+
+        this.logger.debug('init');
+
+        this.contentStackClient = new ContentStackClient({
+            apiKey: this.apiKey,
+            managementToken: this.managementToken,
+            branch: this.branch,
+            logger: this.logger
+        });
+
+        // If running locally, use ContentPoller instead of webhook unless explicitly debugging webhooks
+        if (localDev && !webhookUrl) {
+            this.logger.info(`no webhookUrl provided, using content poller`);
+            this.useContentPoller = true;
+        } else {
+            // if not a local dev, or webhook was provided, do not skip fetch on start
+            this.skipFetchOnStartIfCache = false;
+            this.updateCacheOnFirstPoll = false;
+        }
+
+        await this.reset();
+
+        await createWebhookIfNeeded({
+            webhookUrl,
+            publishEnvironmentName: this.publishEnvironment.name,
+            branch: this.branch,
+            isLocalDev: localDev,
+            contentStackClient: this.contentStackClient,
+            logger: this.logger
+        });
+
+        this.syncContext = ((await this.cache.get('syncContext')) as SyncContext) ?? {};
+    }
+
+    async reset(): Promise<void> {
+        const environments = await this.contentStackClient.getEnvironments();
+        this.publishEnvironment = resolvePublishEnvironment({
+            environments,
+            publishEnvironmentName: this.publishEnvironmentName,
+            logger: this.logger
+        });
+
+        if (this.authtoken) {
+            const stack = await this.contentStackClient.getStack(this.authtoken);
+            this.masterLocale = stack.master_locale;
+            await this.fetchUsers();
+        }
+
+        // The contentPoller updates its syncContext property internally when
+        // it gets an updated content. But, the actual cached data is not
+        // updated. Therefore, when content source module is restarted, we need
+        // to reset the contentPoller's internal syncContext, so it will be
+        // able to fetch all the updated content from its cached state.
+        if (this.contentPoller) {
+            this.contentPoller.setSyncContext(this.syncContext);
+        }
+    }
+
+    async destroy(): Promise<void> {}
+
+    startWatchingContentUpdates() {
+        this.logger.debug('startWatchingContentUpdates');
+        if (!this.useContentPoller) {
+            return;
+        }
+        if (this.contentPoller) {
+            this.stopWatchingContentUpdates();
+        }
+        const { models } = this.cache.getSchema();
+        const modelNames = models.filter((model) => ['data', 'page'].includes(model.type)).map((model) => model.name);
+        this.contentPoller = new ContentPoller({
+            modelNames,
+            contentStackClient: this.contentStackClient,
+            syncContext: this.syncContext,
+            logger: this.logger,
+            notificationCallback: async (syncResult) => {
+                if (syncResult.contentTypes.length || syncResult.globalFields.length) {
+                    this.logger.debug('schema was changed, invalidate schema');
+                    this.cache.invalidateSchema();
+                } else {
+                    const result = await this.convertSyncResult(syncResult);
+                    await this.cache.updateContent(result);
+                }
+            }
+        });
+        this.contentPoller.start();
+    }
+
+    stopWatchingContentUpdates() {
+        this.logger.debug('stopWatchingContentUpdates');
+        if (this.contentPoller) {
+            this.contentPoller.stop();
+            this.contentPoller = null;
+        }
+    }
+
+    async convertSyncResult(syncResult: SyncResult) {
+        if (this.updateCacheOnFirstPoll) {
+            if (syncResult.entries.length || syncResult.assets.length) {
+                if (syncResult.entries.length) {
+                    const cachedEntries = ((await this.cache.get('entries')) as Entry[]) ?? [];
+                    this.syncContext.lastUpdatedEntryDate = getLastUpdatedEntityDate(syncResult.entries);
+                    const entries = _.unionBy(syncResult.entries, cachedEntries, 'uid');
+                    await this.cache.set('entries', entries);
+                }
+                if (syncResult.assets.length) {
+                    const cachedAssets = ((await this.cache.get('assets')) as Asset[]) ?? [];
+                    this.syncContext.lastUpdatedAssetDate = getLastUpdatedEntityDate(syncResult.assets);
+                    const assets = _.unionBy(syncResult.assets, cachedAssets, 'uid');
+                    await this.cache.set('assets', assets);
+                }
+                await this.cache.set('syncContext', this.syncContext);
+                this.updateCacheOnFirstPoll = false;
+            }
+        }
+
+        if (this.authtoken) {
+            const hasMissingUser = [...syncResult.entries, ...syncResult.assets].some((entity) => userMissingInMap(this.usersById, entity));
+            if (hasMissingUser) {
+                await this.fetchUsers();
+            }
+        }
+
+        const documents = convertEntries({
+            entries: syncResult.entries,
+            apiKey: this.apiKey,
+            getModelByName: this.cache.getModelByName,
+            usersById: this.usersById,
+            publishEnvironment: this.publishEnvironment,
+            logger: this.logger
+        });
+        const assets = convertAssets({
+            assets: syncResult.assets,
+            apiKey: this.apiKey,
+            usersById: this.usersById,
+            publishEnvironment: this.publishEnvironment
+        });
+
+        return {
+            documents,
+            assets,
+            deletedDocumentIds: syncResult.deletedEntries.map((entry) => entry.uid),
+            deletedAssetIds: syncResult.deletedAssets.map((asset) => asset.uid)
+        };
+    }
+
+    async fetchUsers() {
+        if (this.authtoken) {
+            const users = await this.contentStackClient.getUsers(this.authtoken);
+            this.usersById = _.keyBy(users, 'uid');
+        }
+    }
+
+    async getSchema(): Promise<StackbitTypes.Schema<SchemaContext, ModelContext>> {
+        this.logger.debug('getSchema');
+        const [globalFields, contentTypes, contentStackLocales] = await Promise.all([
+            this.contentStackClient.getGlobalFields(),
+            this.contentStackClient.getContentTypes(),
+            this.contentStackClient.getLocales()
+        ]);
+
+        const models = convertModels({ contentStackModels: [...globalFields, ...contentTypes] });
+        const locales = convertLocales({ contentStackLocales, masterLocale: this.masterLocale, logger: this.logger });
+
+        // Check if one of the content types was changed from the last time the
+        // content types were fetched, in which case remove all cached content.
+        const lastUpdatedContentTypeDate = getLastUpdatedEntityDate(contentTypes);
+        const lastUpdatedGlobalFieldDate = getLastUpdatedEntityDate(globalFields);
+        if (
+            this.syncContext.lastUpdatedContentTypeDate !== lastUpdatedContentTypeDate ||
+            this.syncContext.lastUpdatedGlobalFieldDate !== lastUpdatedGlobalFieldDate
+        ) {
+            this.logger.debug(
+                `last updated content type date '${lastUpdatedContentTypeDate}' is different from cached ` +
+                    `syncContext.lastUpdatedContentTypeDate '${this.syncContext.lastUpdatedContentTypeDate}', ` +
+                    `or last updated global field date '${lastUpdatedGlobalFieldDate}' is different from cached ` +
+                    `syncContext.lastUpdatedGlobalFieldDate '${this.syncContext.lastUpdatedGlobalFieldDate}', ` +
+                    `clearing cache`
+            );
+            await this.cache.remove('entries');
+            await this.cache.remove('assets');
+            this.skipFetchOnStartIfCache = false;
+            this.updateCacheOnFirstPoll = false;
+            this.syncContext = { lastUpdatedContentTypeDate, lastUpdatedGlobalFieldDate };
+            await this.cache.set('syncContext', this.syncContext);
+        }
+
+        this.logger.debug(`got ${contentTypes.length} content types, ${globalFields.length} global fields, ${locales.length} locales`);
+        return {
+            models,
+            locales,
+            context: null
+        };
+    }
+
+    async getDocuments(): Promise<StackbitTypes.Document<DocumentContext>[]> {
+        this.logger.debug('getDocuments');
+        const { models } = this.cache.getSchema();
+        const modelNames = models.filter((model) => ['data', 'page'].includes(model.type)).map((model) => model.name);
+
+        let entries: Entry[];
+        const cachedEntries = ((await this.cache.get('entries')) as Entry[]) ?? [];
+        try {
+            if (this.syncContext.lastUpdatedEntryDate && cachedEntries) {
+                entries = cachedEntries;
+                if (!this.skipFetchOnStartIfCache) {
+                    this.logger.debug(
+                        `got ${cachedEntries.length} entries from cache, fetching entries updated after ${this.syncContext.lastUpdatedEntryDate}`
+                    );
+                    const updatedEntries = await this.contentStackClient.getAllEntriesUpdatedAfter(modelNames, this.syncContext.lastUpdatedEntryDate);
+                    this.logger.debug(`got ${updatedEntries.length} updated/created entries after ${this.syncContext.lastUpdatedEntryDate}`);
+                    if (updatedEntries.length) {
+                        this.syncContext.lastUpdatedEntryDate = getLastUpdatedEntityDate(updatedEntries);
+                        entries = _.unionBy(updatedEntries, cachedEntries, 'uid');
+                        await this.cache.set('entries', entries);
+                    }
+                }
+            } else {
+                entries = await this.contentStackClient.getAllEntries(modelNames);
+                await this.cache.set('entries', entries);
+                this.syncContext.lastUpdatedEntryDate = getLastUpdatedEntityDate(entries);
+            }
+        } catch (error: any) {
+            // Stackbit won't be able to work properly even if one of the entries was not fetched.
+            // All api methods use Contentstack's API client that handles errors and retries automatically.
+            this.logger.error(`Failed fetching documents from Contentstack, error: ${error.message}`);
+            throw new Error(`Failed fetching documents from Contentstack, error: ${error.message}`);
+        }
+        await this.cache.set('syncContext', this.syncContext);
+
+        // TODO: localization: fetch entries per locale, and merge them into localized fields of a single document
+        const documents = convertEntries({
+            entries,
+            apiKey: this.apiKey,
+            getModelByName: this.cache.getModelByName,
+            usersById: this.usersById,
+            publishEnvironment: this.publishEnvironment,
+            logger: this.logger
+        });
+        this.logger.debug(`got ${documents.length} documents`);
+        return documents;
+    }
+
+    async getAssets(): Promise<StackbitTypes.Asset<AssetContext>[]> {
+        this.logger.debug('getAssets');
+
+        let assets: Asset[];
+        const cachedAssets = ((await this.cache.get('assets')) as Asset[]) ?? [];
+        try {
+            if (this.syncContext.lastUpdatedAssetDate && cachedAssets) {
+                assets = cachedAssets;
+                if (!this.skipFetchOnStartIfCache) {
+                    this.logger.debug(`got ${cachedAssets.length} assets from cache, fetching assets updated after ${this.syncContext.lastUpdatedAssetDate}`);
+                    const updatedAssets = await this.contentStackClient.getAssetsUpdatedAfter(this.syncContext.lastUpdatedAssetDate);
+                    this.logger.debug(`got ${updatedAssets.length} updated/created assets after ${this.syncContext.lastUpdatedAssetDate}`);
+                    if (updatedAssets.length) {
+                        this.syncContext.lastUpdatedAssetDate = getLastUpdatedEntityDate(updatedAssets);
+                        assets = _.unionBy(updatedAssets, cachedAssets, 'uid');
+                        await this.cache.set('assets', assets);
+                    }
+                }
+            } else {
+                assets = await this.contentStackClient.getAssets();
+                await this.cache.set('assets', assets);
+                this.syncContext.lastUpdatedAssetDate = getLastUpdatedEntityDate(assets);
+            }
+        } catch (error: any) {
+            // Stackbit won't be able to work properly even if one of the entries or the assets was not fetched.
+            // All api methods use Contentstack's API client that handles errors and retries automatically.
+            this.logger.error(`Failed fetching assets from Contentstack, error: ${error.message}`);
+            throw new Error(`Failed fetching assets from Contentstack, error: ${error.message}`);
+        }
+        await this.cache.set('syncContext', this.syncContext);
+
+        const stackbitAssets = convertAssets({
+            assets: assets,
+            apiKey: this.apiKey,
+            usersById: this.usersById,
+            publishEnvironment: this.publishEnvironment
+        });
+        this.logger.debug(`got ${stackbitAssets.length} documents`);
+        return stackbitAssets;
+    }
+
+    async hasAccess(options: { userContext?: UserWithContext }): Promise<{
+        hasConnection: boolean;
+        hasPermissions: boolean;
+    }> {
+        // TODO: add ContentStack OAuth and validate user's access to the current stack/branch
+        return {
+            hasConnection: true,
+            hasPermissions: true
+        };
+    }
+
+    async createDocument(options: {
+        updateOperationFields: Record<string, StackbitTypes.UpdateOperationField>;
+        model: ModelWithContext;
+        locale?: string;
+        defaultLocaleDocumentId?: string;
+        userContext?: UserWithContext;
+    }): Promise<{ documentId: string }> {
+        this.logger.debug('createDocument');
+        const entry = createEntryFromOperationFields({
+            updateOperationFields: options.updateOperationFields,
+            model: options.model,
+            getDocumentById: this.cache.getDocumentById,
+            getModelByName: this.cache.getModelByName,
+            logger: this.logger
+        });
+        const newEntry = await this.contentStackClient.createEntry(options.model.name, entry);
+        return { documentId: newEntry.uid };
+    }
+
+    async updateDocument(options: {
+        document: DocumentWithContext;
+        operations: StackbitTypes.UpdateOperation[];
+        userContext?: UserWithContext;
+    }): Promise<void> {
+        this.logger.debug('updateDocument');
+        const { document, operations } = options;
+        const entry = await this.contentStackClient.getEntry(document.modelName, document.id);
+        const updatedEntry = updateEntryFromUpdateOperations({
+            entry,
+            updateOperations: operations,
+            getDocumentById: this.cache.getDocumentById,
+            getModelByName: this.cache.getModelByName,
+            logger: this.logger
+        });
+        await this.contentStackClient.updateEntry(updatedEntry);
+    }
+
+    async deleteDocument(options: { document: StackbitTypes.Document<unknown>; userContext?: UserWithContext }): Promise<void> {
+        this.logger.debug('deleteDocument');
+        await this.contentStackClient.deleteEntry(options.document.modelName, options.document.id);
+    }
+
+    async uploadAsset(options: {
+        url?: string | undefined;
+        base64?: string | undefined;
+        fileName: string;
+        mimeType: string;
+        locale?: string | undefined;
+        userContext?: UserWithContext;
+    }): Promise<StackbitTypes.Asset<AssetContext>> {
+        this.logger.debug('uploadAsset');
+        const tempName = `${uuidv4()}-${options.fileName}`;
+        let asset: Asset;
+        try {
+            if (options.base64) {
+                // TODO: write to .stackbit/cache folder
+                await writeFile(tempName, Buffer.from(options.base64, 'base64'));
+            } else {
+                await downloadFile(options.url!, tempName);
+            }
+            asset = await this.contentStackClient.uploadImage(tempName, options.fileName);
+            const locales = this.cache.getSchema().locales ?? [];
+            const defaultLocale = locales.find((locale) => locale.default)?.code;
+            await asset.publish({
+                publishDetails: {
+                    environments: [this.publishEnvironment.name],
+                    locales: [defaultLocale!]
+                },
+                locale: defaultLocale
+            });
+        } finally {
+            await unlink(tempName);
+        }
+        this.logger.debug(`uploaded asset, new asset id: ${asset.uid}`);
+
+        return convertAsset({
+            asset,
+            apiKey: this.apiKey,
+            usersById: this.usersById,
+            publishEnvironment: this.publishEnvironment
+        });
+    }
+
+    async validateDocuments(options: {
+        documents: StackbitTypes.Document<unknown>[];
+        assets: StackbitTypes.Asset<unknown>[];
+        locale?: string | undefined;
+        userContext?: UserWithContext;
+    }): Promise<{ errors: StackbitTypes.ValidationError[] }> {
+        const validations: StackbitTypes.ValidationError[] = [];
+        return { errors: validations };
+    }
+
+    async publishDocuments(options: {
+        documents: StackbitTypes.Document<DocumentContext>[];
+        assets: StackbitTypes.Asset<AssetContext>[];
+        userContext?: UserWithContext;
+    }): Promise<void> {
+        this.logger.debug('publishDocuments');
+        await this.contentStackClient.publishDocuments({
+            documents: options.documents,
+            publishEnvironmentName: this.publishEnvironment.name
+        });
+    }
+
+    async onWebhook(data: { data: WebhookPayload; headers: Record<string, string> }): Promise<void> {
+        const webhookData = data.data;
+        const updates: StackbitTypes.ContentChanges<DocumentContext, AssetContext> = {
+            assets: [],
+            documents: [],
+            deletedDocumentIds: [],
+            deletedAssetIds: []
+        };
+
+        // check that the webhook is related to the current branch, if not ignore
+        if (this.branch && this.branch !== webhookData.data.branch.uid) {
+            return;
+        }
+
+        this.logger.debug(`got webhook for ${webhookData.event} ${webhookData.module}`);
+
+        if (webhookData.module === 'entry') {
+            switch (webhookData.event) {
+                case 'create':
+                case 'update': {
+                    if (userMissingInMap(this.usersById, webhookData.data.entry as Entry)) {
+                        await this.fetchUsers();
+                    }
+                    const document = convertEntry({
+                        entry: {
+                            ...webhookData.data.entry,
+                            content_type_uid: webhookData.data.content_type.uid,
+                            publish_details: [],
+                            _branch: webhookData.data.branch.uid
+                        } as unknown as Entry,
+                        status: webhookData.event === 'create' ? 'added' : 'modified',
+                        apiKey: this.apiKey,
+                        getModelByName: this.cache.getModelByName,
+                        usersById: this.usersById,
+                        publishEnvironment: this.publishEnvironment,
+                        logger: this.logger
+                    });
+                    updates.documents!.push(document);
+                    break;
+                }
+                case 'publish': {
+                    if (webhookData.data.environment.uid !== this.publishEnvironment.uid) {
+                        this.logger.debug(
+                            `entry was published in an environment '${webhookData.data.environment.name}' ` +
+                                `different from the publish environment '${this.publishEnvironment.name}', ignoring the webhook'`
+                        );
+                        break;
+                    }
+                    if (userMissingInMap(this.usersById, webhookData.data.entry as Entry)) {
+                        await this.fetchUsers();
+                    }
+                    const document = convertEntry({
+                        entry: {
+                            ...webhookData.data.entry,
+                            content_type_uid: webhookData.data.content_type.uid,
+                            publish_details: [],
+                            _branch: webhookData.data.branch.uid
+                        } as unknown as Entry,
+                        status: 'published',
+                        apiKey: this.apiKey,
+                        getModelByName: this.cache.getModelByName,
+                        usersById: this.usersById,
+                        publishEnvironment: this.publishEnvironment,
+                        logger: this.logger
+                    });
+                    updates.documents!.push(document);
+                    break;
+                }
+                case 'unpublish':
+                    if (webhookData.data.environment.uid !== this.publishEnvironment.uid) {
+                        this.logger.debug(
+                            `entry was published in an environment '${webhookData.data.environment.name}' ` +
+                                `different from the publish environment '${this.publishEnvironment.name}', ignoring the webhook'`
+                        );
+                        break;
+                    }
+                    updates.deletedDocumentIds!.push(webhookData.data.entry.uid);
+                    break;
+                case 'delete':
+                    updates.deletedDocumentIds!.push(webhookData.data.entry.uid);
+                    break;
+            }
+        } else if (webhookData.module === 'asset') {
+            switch (webhookData.event) {
+                case 'create':
+                case 'update': {
+                    if (userMissingInMap(this.usersById, webhookData.data.asset as Asset)) {
+                        await this.fetchUsers();
+                    }
+                    const asset = convertAsset({
+                        asset: {
+                            ...webhookData.data.asset,
+                            publish_details: [],
+                            _branch: webhookData.data.branch.uid
+                        } as unknown as Asset,
+                        apiKey: this.apiKey,
+                        usersById: this.usersById,
+                        publishEnvironment: this.publishEnvironment
+                    });
+                    updates.assets!.push(asset);
+                    break;
+                }
+                case 'publish': {
+                    if (webhookData.data.environment.uid !== this.publishEnvironment.uid) {
+                        this.logger.debug(
+                            `asset was published in an environment '${webhookData.data.environment.name}' ` +
+                                `different from the publish environment '${this.publishEnvironment.name}', ignoring the webhook'`
+                        );
+                        return;
+                    }
+                    if (userMissingInMap(this.usersById, webhookData.data.asset as Asset)) {
+                        await this.fetchUsers();
+                    }
+                    const asset = convertAsset({
+                        asset: {
+                            ...webhookData.data.asset,
+                            publish_details: [],
+                            _branch: webhookData.data.branch.uid
+                        } as unknown as Asset,
+                        apiKey: this.apiKey,
+                        usersById: this.usersById,
+                        publishEnvironment: this.publishEnvironment
+                    });
+                    updates.assets!.push(asset);
+                    break;
+                }
+                case 'unpublish':
+                    if (webhookData.data.environment.uid !== this.publishEnvironment.uid) {
+                        this.logger.debug(
+                            `asset was published in an environment '${webhookData.data.environment.name}' ` +
+                                `different from the publish environment '${this.publishEnvironment.name}', ignoring the webhook'`
+                        );
+                        return;
+                    }
+                    updates.deletedAssetIds?.push(webhookData.data.asset.uid);
+                    break;
+                case 'delete':
+                    updates.deletedAssetIds?.push(webhookData.data.asset.uid);
+                    break;
+            }
+        } else if (webhookData.module === 'content_type' || webhookData.module === 'global_field') {
+            this.logger.debug(`webhook for '${webhookData.module}' invalidate schema`);
+            this.cache.invalidateSchema();
+            return;
+        }
+
+        this.logger.debug(
+            `update content from webhook, ` +
+                `documents: ${updates.documents?.length}, ` +
+                `assets: ${updates.assets?.length}, ` +
+                `deleted documents: ${updates.deletedDocumentIds?.length}, ` +
+                `deleted assets: ${updates.deletedAssetIds?.length}`
+        );
+        this.cache.updateContent(updates);
+    }
+}