@jungvonmatt/contentful-ssg 1.7.1 → 1.7.5-alpha.0

package/README.md

@@ -47,7 +47,7 @@ npx cssg init --typescript
 | spaceId            | `string`                                                              | `undefined`   | Contentful Space id                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | environmentId      | `string`                                                              | `'master'`    | Contentful Environment id                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | format             | `string`\|`function`\|`object`                                        | `'yaml'`      | File format ( `yaml`, `toml`, `md`, `json`) You can add a function returning the format or you can add a mapping object like `{yaml: [glob pattern]}` ([pattern](https://github.com/micromatch/micromatch) should match the directory)                                                                                                                                                                                                                                     |
-| plugins            | `[string]`\|`[[string, options]]`\|`[{resolve:'string', options:{}}]` | `[]`          | Add plugins to contentful-ssg. See [Plugins](#plugins) |
+| plugins            | `[string]`\|`[[string, options]]`\|`[{resolve:'string', options:{}}]` | `[]`          | Add plugins to contentful-ssg. See [Plugins](#plugins)                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | directory          | `string`                                                              | `'./content'` | Base directory for content files.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | validate           | `function`                                                            | `undefined`   | Pass `function(transformContext, runtimeContext){...}` to validate an entry. Return `false` to skip the entry completely. Without a validate function entries with a missing required field are skipped.                                                                                                                                                                                                                                                                   |
 | transform          | `function`                                                            | `undefined`   | Pass `function(transformContext, runtimeContext){...}` to modify the stored object. Return `undefined` to skip the entry completely. (no file will be written)                                                                                                                                                                                                                                                                                                             |
@@ -71,6 +71,7 @@ plugins: ['my-plugin-package', './plugins/my-local-plugin]
 All plugins can have options specified by wrapping the name and an options object in an array inside your config or by using a more verbose object notation.
 
 For specifying no options, these are all equivalent:
+
 ```js
 {
   "plugins": ["my-plugin", ["my-plugin"], ["my-plugin", {}], {resolve: "my-plugin", options: {}}]
@@ -78,6 +79,7 @@ For specifying no options, these are all equivalent:
 ```
 
 To specify an option, pass an object with the keys as the option names.
+
 ```js
 {
   "plugins": [
@@ -225,7 +227,6 @@ itself is waiting for the current entry to be transformed.
 
       // Do something usefull with the transformed data
       // which you can't do with context.entryMap.get('<contentful-id>')
-
     } catch (error) {
       // Entry isn't available, the transform method for the entry throws an error
       // or we encountered a cyclic dependency
@@ -245,10 +246,25 @@ npx cssg fetch
 ```
 
 To see all available command line options call
+
 ```bash
 npx cssg help fetch
 ```
 
+### watch
+
+Same as `fetch` but also starts a webserver listening for changes and registers a contentful webhook
+
+```bash
+npx cssg watch
+```
+
+To see all available command line options call
+
+```bash
+npx cssg help watch
+```
+
 ## Example configuration
 
 ### Grow

package/dist/__test__/mock.d.ts

@@ -1,11 +1,11 @@
-import type { Config, RuntimeContext, TransformContext } from '../types.js';
+import type { Entry, Config, RuntimeContext, TransformContext } from '../types.js';
 export declare const readFixture: (file: any) => Promise<any>;
 export declare const readFixtureSync: (file: any) => any;
 export declare const getContent: () => Promise<{
-    entries: any;
-    assets: any;
-    contentTypes: any;
-    locales: any;
+    entries: Entry[];
+    assets: import("contentful").Asset[];
+    contentTypes: import("contentful").ContentType[];
+    locales: import("contentful").Locale[];
     assetLink: {
         sys: {
             id: string;
@@ -20,8 +20,10 @@ export declare const getContent: () => Promise<{
             linkType: string;
         };
     };
-    entry: any;
-    asset: any;
+    entry: Entry;
+    asset: import("contentful").Asset;
+    assetMap: Map<string, import("contentful").Asset>;
+    entryMap: Map<string, Entry>;
 }>;
 export declare const getConfig: (fixture?: Partial<Config>) => Config;
 export declare const getRuntimeContext: (fixture?: Partial<RuntimeContext>) => RuntimeContext;

package/dist/__test__/mock.js

@@ -19,10 +19,10 @@ export const readFixtureSync = (file) => {
     return cache.get(file);
 };
 export const getContent = async () => {
-    const assets = await readFixture('assets.json');
-    const entries = await readFixture('entries.json');
-    const locales = await readFixture('locales.json');
-    const contentTypes = await readFixture('content_types.json');
+    const assets = (await readFixture('assets.json'));
+    const entries = (await readFixture('entries.json'));
+    const locales = (await readFixture('locales.json'));
+    const contentTypes = (await readFixture('content_types.json'));
     const [entry] = entries;
     const [asset] = assets;
     const assetLink = {
@@ -39,7 +39,20 @@ export const getContent = async () => {
             linkType: LINK_TYPE_ENTRY,
         },
     };
-    return { entries, assets, contentTypes, locales, assetLink, entryLink, entry, asset };
+    const assetMap = new Map(assets.map((asset) => [asset.sys.id, asset]));
+    const entryMap = new Map(entries.map((entry) => [entry.sys.id, entry]));
+    return {
+        entries,
+        assets,
+        contentTypes,
+        locales,
+        assetLink,
+        entryLink,
+        entry,
+        asset,
+        assetMap,
+        entryMap,
+    };
 };
 export const getConfig = (fixture = {}) => ({
     directory: 'test',

package/dist/cli.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import path from 'path';
 import chalk from 'chalk';
+import ngrok from 'ngrok';
+import getPort from 'get-port';
+import exitHook from 'async-exit-hook';
 import { existsSync } from 'fs';
 import { readFile } from 'fs/promises';
 import { outputFile } from 'fs-extra';
@@ -10,8 +13,10 @@ import dotenv from 'dotenv';
 import dotenvExpand from 'dotenv-expand';
 import { logError, confirm, askAll, askMissing } from './lib/ui.js';
 import { omitKeys } from './lib/object.js';
+import { getApp } from './server/index.js';
 import { getConfig, getEnvironmentConfig } from './lib/config.js';
 import { run } from './index.js';
+import { addWatchWebhook, resetSync } from './lib/contentful.js';
 const env = dotenv.config();
 dotenvExpand(env);
 const parseFetchArgs = (cmd) => ({
@@ -90,8 +95,50 @@ program
     .option('-v, --verbose', 'Verbose output')
     .option('--ignore-errors', 'No error return code when transform has errors')
     .action(actionRunner(async (cmd) => {
+    await resetSync();
     const config = await getConfig(parseFetchArgs(cmd || {}));
     const verified = await askMissing(config);
     return run(verified);
 }));
+program
+    .command('watch')
+    .description('Fetch content objects && watch for changes')
+    .option('-p, --preview', 'Fetch with preview mode')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--url <url>', 'Url where the the server is reachable from the outside')
+    .option('--ignore-errors', 'No error return code when transform has errors')
+    .action(actionRunner(async (cmd) => {
+    await resetSync();
+    const config = await getConfig(parseFetchArgs(cmd || {}));
+    const verified = await askMissing(config);
+    let prev = await run({ ...verified, sync: true });
+    let port = await getPort({ port: 1314 });
+    if (cmd.url) {
+        const url = new URL(cmd.url);
+        port = url.port || url.protocol === 'https:' ? 443 : 80;
+    }
+    const app = getApp(async () => {
+        prev = await run({ ...verified, sync: true }, prev);
+    });
+    const server = app.listen(port);
+    const stopServer = async () => new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+    const url = cmd.url || (await ngrok.connect(port));
+    console.log(`\n  Listening for hooks on ${chalk.cyan(url)}\n`);
+    const webhook = await addWatchWebhook(verified, url);
+    exitHook(async (cb) => {
+        await webhook.delete();
+        await stopServer();
+        await resetSync();
+        cb();
+    });
+}));
 program.parse(process.argv);

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import type { Config } from './types.js';
-export declare const run: (config: Config) => Promise<void>;
+import type { Config, RunResult, RuntimeContext } from './types.js';
+export declare const cleanupPrevData: (ctx: RuntimeContext, prev: RunResult) => void;
+export declare const run: (config: Config, prev?: RunResult) => Promise<RunResult>;

package/dist/index.js

@@ -1,14 +1,15 @@
-import Listr from 'listr';
-import { BehaviorSubject } from 'rxjs';
 import chalk from 'chalk';
-import { getContentTypeId, getContentId } from './lib/contentful.js';
-import { setup } from './tasks/setup.js';
+import Listr from 'listr';
+import { ReplaySubject } from 'rxjs';
+import { getContentId, getContentTypeId, isSyncRequest } from './lib/contentful.js';
+import { ValidationError } from './lib/error.js';
+import { collectParentValues, collectValues, waitFor } from './lib/utils.js';
 import { fetch } from './tasks/fetch.js';
 import { localize } from './tasks/localize.js';
+import { remove } from './tasks/remove.js';
+import { setup } from './tasks/setup.js';
 import { transform } from './tasks/transform.js';
 import { write } from './tasks/write.js';
-import { collectParentValues, collectValues, waitFor } from './lib/utils.js';
-import { ValidationError } from './lib/error.js';
 class CustomListrRenderer {
     _tasks;
     constructor(tasks) {
@@ -38,7 +39,39 @@ class CustomListrRenderer {
         }
     }
 }
-export const run = async (config) => {
+export const cleanupPrevData = (ctx, prev) => {
+    const entryMap = prev.localized?.[ctx.defaultLocale]?.entryMap ?? new Map();
+    ctx.data.deletedEntries =
+        ctx?.data?.deletedEntries?.map((entry) => {
+            if (entryMap.has(entry.sys.id)) {
+                const prevEntry = entryMap.get(entry.sys.id);
+                return { ...prevEntry, sys: { ...prevEntry.sys, ...entry.sys } };
+            }
+            return entry;
+        }) ?? [];
+    ctx.data.locales.forEach((locale) => {
+        if (ctx?.data?.deletedEntries?.length) {
+            ctx.data.deletedEntries.forEach((entry) => {
+                if (prev.localized?.[locale.code]?.entryMap.has(entry.sys.id)) {
+                    prev.localized?.[locale.code]?.entryMap.delete(entry.sys.id);
+                    prev.localized[locale.code].entries = Array.from(prev.localized?.[locale.code]?.entryMap.values());
+                }
+            });
+        }
+        if (ctx?.data?.deletedAssets?.length) {
+            ctx.data.deletedAssets.forEach((asset) => {
+                if (prev.localized?.[locale.code]?.assetMap.has(asset.sys.id)) {
+                    prev.localized?.[locale.code]?.assetMap.delete(asset.sys.id);
+                    prev.localized[locale.code].assets = Array.from(prev.localized?.[locale.code]?.assetMap.values());
+                }
+            });
+        }
+    });
+};
+export const run = async (config, prev = {
+    observables: {},
+    localized: {},
+}) => {
     const tasks = new Listr([
         {
             title: 'Setup',
@@ -46,7 +79,10 @@ export const run = async (config) => {
         },
         {
             title: 'Pulling data from contentful',
-            task: async (ctx) => fetch(ctx, config),
+            task: async (ctx) => {
+                await fetch(ctx, config);
+                cleanupPrevData(ctx, prev);
+            },
         },
         {
             title: 'Localize data',
@@ -57,6 +93,41 @@ export const run = async (config) => {
             skip: (ctx) => !ctx.hooks.has('before'),
             task: async (ctx) => ctx.hooks.before(),
         },
+        {
+            title: 'Remove deleted files',
+            skip: (ctx) => (ctx.data.deletedEntries ?? []).length === 0,
+            task: async (ctx) => {
+                const { locales = [], deletedEntries = [] } = ctx.data;
+                const tasks = locales.map((locale) => ({
+                    title: `${locale.code}`,
+                    task: async () => {
+                        const data = ctx.localized.get(locale.code);
+                        if (!prev?.observables?.[locale.code]) {
+                            prev.observables[locale.code] = new ReplaySubject();
+                        }
+                        const subject = prev.observables[locale.code];
+                        const observable = subject.asObservable();
+                        const promises = deletedEntries.map(async (entry) => {
+                            const id = getContentId(entry);
+                            const contentTypeId = getContentTypeId(entry);
+                            const utils = {};
+                            const transformContext = {
+                                ...data,
+                                id,
+                                contentTypeId,
+                                entry,
+                                locale,
+                                observable,
+                                utils,
+                            };
+                            return remove(transformContext, ctx, config);
+                        });
+                        return Promise.all(promises);
+                    },
+                }));
+                return new Listr(tasks, { concurrent: true });
+            },
+        },
         {
             title: 'Writing files',
             task: async (ctx) => {
@@ -64,10 +135,24 @@ export const run = async (config) => {
                 const tasks = locales.map((locale) => ({
                     title: `${locale.code}`,
                     task: async () => {
-                        const subject = new BehaviorSubject(null);
-                        const observable = subject.asObservable();
                         const data = ctx.localized.get(locale.code);
                         const { entries = [] } = data || {};
+                        if (!prev?.observables?.[locale.code]) {
+                            prev.observables[locale.code] = new ReplaySubject();
+                        }
+                        const subject = prev.observables[locale.code];
+                        const observable = subject.asObservable();
+                        data.assetMap = new Map([
+                            ...(prev?.localized[locale.code]?.assetMap ?? new Map()),
+                            ...data.assetMap,
+                        ]);
+                        data.entryMap = new Map([
+                            ...(prev?.localized[locale.code]?.entryMap ?? new Map()),
+                            ...data.entryMap,
+                        ]);
+                        data.entries = Array.from(data.entryMap.values());
+                        data.assets = Array.from(data.assetMap.values());
+                        prev.localized[locale.code] = data;
                         const promises = entries.map(async (entry) => {
                             const id = getContentId(entry);
                             const contentTypeId = getContentTypeId(entry);
@@ -107,6 +192,7 @@ export const run = async (config) => {
                                 else {
                                     ctx.stats.addError(transformContext, error);
                                 }
+                                await remove(transformContext, ctx, config);
                             }
                         });
                         return Promise.all(promises);
@@ -122,13 +208,15 @@ export const run = async (config) => {
         },
         {
             title: 'Cleanup',
+            skip: () => isSyncRequest(),
             task: async (ctx) => ctx.fileManager.cleanup(),
         },
     ], { renderer: CustomListrRenderer });
     const ctx = await tasks.run();
     await ctx.stats.print();
-    console.log('\n---------------------------------------------');
-    if (ctx.stats.errors?.length && !config.ignoreErrors) {
+    console.log('\n  -------------------------------------------');
+    if (!ctx.config.sync && ctx.stats.errors?.length && !config.ignoreErrors) {
         process.exit(1);
     }
+    return prev;
 };

package/dist/lib/contentful.d.ts

@@ -1,4 +1,4 @@
-import type { Space } from 'contentful-management/types';
+import type { Space, CreateWebhooksProps } from 'contentful-management/types';
 import type { ContentfulConfig, FieldSettings, Node, Entry, ContentType } from '../types.js';
 import contentful from 'contentful';
 export declare const FIELD_TYPE_SYMBOL = "Symbol";
@@ -15,6 +15,7 @@ export declare const FIELD_TYPE_OBJECT = "Object";
 export declare const LINK_TYPE_ASSET = "Asset";
 export declare const LINK_TYPE_ENTRY = "Entry";
 export declare const MAX_ALLOWED_LIMIT = 1000;
+export declare const SYNC_TOKEN_FILENAME = ".contentful_sync.lock";
 export declare const getContentTypeId: <T extends contentful.Asset | Entry | contentful.Entry<unknown>>(node: T) => string;
 export declare const getEnvironmentId: <T extends Node>(node: T) => string;
 export declare const getContentId: <T extends contentful.ContentType | contentful.Asset | Entry | contentful.Entry<unknown>>(node: T) => string;
@@ -24,12 +25,29 @@ export declare const getEnvironments: (options: ContentfulConfig) => Promise<imp
 export declare const getEnvironment: (options: ContentfulConfig) => Promise<import("contentful-management/types").Environment>;
 export declare const getApiKey: (options: ContentfulConfig) => Promise<string>;
 export declare const getPreviewApiKey: (options: ContentfulConfig) => Promise<string>;
+export declare const getWebhooks: (options: ContentfulConfig) => Promise<import("contentful-management/types").WebHooks[]>;
+export declare const addWebhook: (options: ContentfulConfig, id: string, data: CreateWebhooksProps) => Promise<import("contentful-management/types").WebHooks>;
+export declare const deleteWebhook: (options: ContentfulConfig, id: string) => Promise<void>;
+export declare const addWatchWebhook: (options: ContentfulConfig, url: string) => Promise<import("contentful-management/types").WebHooks>;
+export declare const isSyncRequest: () => boolean;
+export declare const resetSync: () => Promise<true | void>;
 export declare const getContent: (options: ContentfulConfig) => Promise<{
+    entries: contentful.Entry<any>[];
+    assets: contentful.Asset[];
+    deletedEntries: contentful.Entry<any>[];
+    deletedAssets: contentful.Asset[];
+    contentTypes: contentful.ContentType[];
+    locales: contentful.Locale[];
+} | {
     entries: Entry[];
     assets: contentful.Asset[];
     contentTypes: contentful.ContentType[];
     locales: contentful.Locale[];
+    deletedEntries?: undefined;
+    deletedAssets?: undefined;
 }>;
+export declare const getEntriesLinkedToEntry: (options: ContentfulConfig, id: string) => Promise<Entry[]>;
+export declare const getEntriesLinkedToAsset: (options: ContentfulConfig, id: string) => Promise<Entry[]>;
 export declare const isContentfulObject: (obj: any) => boolean;
 export declare const isLink: (obj: any) => boolean;
 export declare const isAssetLink: (obj: any) => boolean;

package/dist/lib/contentful.js

@@ -1,3 +1,7 @@
+import { existsSync } from 'fs';
+import { hostname } from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { readFile, unlink, writeFile } from 'fs/promises';
 import contentful from 'contentful';
 import contentfulManagement from 'contentful-management';
 let client;
@@ -16,6 +20,7 @@ export const FIELD_TYPE_OBJECT = 'Object';
 export const LINK_TYPE_ASSET = 'Asset';
 export const LINK_TYPE_ENTRY = 'Entry';
 export const MAX_ALLOWED_LIMIT = 1000;
+export const SYNC_TOKEN_FILENAME = '.contentful_sync.lock';
 export const getContentTypeId = (node) => node?.sys?.contentType?.sys?.id ?? 'unknown';
 export const getEnvironmentId = (node) => node?.sys?.environment?.sys?.id ?? 'unknown';
 export const getContentId = (node) => node?.sys?.id ?? 'unknown';
@@ -89,6 +94,68 @@ export const getPreviewApiKey = async (options) => {
     const { accessToken: previewAccessToken } = previewApiKey;
     return previewAccessToken;
 };
+export const getWebhooks = async (options) => {
+    const space = await getSpace(options);
+    const { items: webhooks = [] } = await space.getWebhooks();
+    return webhooks;
+};
+export const addWebhook = async (options, id, data) => {
+    const space = await getSpace(options);
+    return space.createWebhookWithId(id, data);
+};
+export const deleteWebhook = async (options, id) => {
+    const space = await getSpace(options);
+    const webhook = await space.getWebhook(id);
+    return webhook.delete();
+};
+export const addWatchWebhook = async (options, url) => {
+    let topics = [
+        'ContentType.publish',
+        'ContentType.unpublish',
+        'ContentType.delete',
+        'Entry.archive',
+        'Entry.unarchive',
+        'Entry.publish',
+        'Entry.unpublish',
+        'Entry.delete',
+        'Asset.archive',
+        'Asset.unarchive',
+        'Asset.publish',
+        'Asset.unpublish',
+        'Asset.delete',
+    ];
+    if (options.preview) {
+        topics = [
+            ...topics,
+            'ContentType.save',
+            'Entry.save',
+            'Entry.auto_save',
+            'Asset.save',
+            'Asset.auto_save',
+        ];
+    }
+    const uuid = uuidv4();
+    return addWebhook(options, uuid, {
+        name: `contentful-ssg (${hostname()})`,
+        url,
+        httpBasicUsername: null,
+        topics,
+        filters: [
+            {
+                equals: [
+                    {
+                        doc: 'sys.environment.sys.id',
+                    },
+                    options.environmentId,
+                ],
+            },
+        ],
+        transformation: {
+            includeContentLength: true,
+        },
+        headers: [],
+    });
+};
 const pagedGet = async (apiClient, { method, skip = 0, aggregatedResponse = null, query = null }) => {
     const fullQuery = {
         skip,
@@ -115,6 +182,25 @@ const pagedGet = async (apiClient, { method, skip = 0, aggregatedResponse = null
     }
     return aggregatedResponse;
 };
+const sync = async (apiClient) => {
+    const options = { initial: true };
+    if (existsSync(SYNC_TOKEN_FILENAME)) {
+        options.nextSyncToken = await readFile(SYNC_TOKEN_FILENAME, 'utf8');
+        delete options.initial;
+    }
+    const response = (await apiClient.sync(options));
+    if (response.nextSyncToken) {
+        await writeFile(SYNC_TOKEN_FILENAME, response.nextSyncToken);
+    }
+    return response;
+};
+export const isSyncRequest = () => existsSync(SYNC_TOKEN_FILENAME);
+export const resetSync = async () => {
+    if (isSyncRequest()) {
+        return unlink(SYNC_TOKEN_FILENAME);
+    }
+    return true;
+};
 export const getContent = async (options) => {
     const apiClient = getClient(options);
     const { items: locales } = await pagedGet(apiClient, {
@@ -123,6 +209,10 @@ export const getContent = async (options) => {
     const { items: contentTypes } = await pagedGet(apiClient, {
         method: 'getContentTypes',
     });
+    if (options.sync) {
+        const { entries, assets, deletedEntries, deletedAssets } = await sync(apiClient);
+        return { entries, assets, deletedEntries, deletedAssets, contentTypes, locales };
+    }
     const { items: entries } = await pagedGet(apiClient, {
         method: 'getEntries',
     });
@@ -131,6 +221,22 @@ export const getContent = async (options) => {
     });
     return { entries, assets, contentTypes, locales };
 };
+export const getEntriesLinkedToEntry = async (options, id) => {
+    const apiClient = getClient(options);
+    const { items: entries } = await pagedGet(apiClient, {
+        method: 'getEntries',
+        query: { links_to_entry: id },
+    });
+    return entries;
+};
+export const getEntriesLinkedToAsset = async (options, id) => {
+    const apiClient = getClient(options);
+    const { items: entries } = await pagedGet(apiClient, {
+        method: 'getEntries',
+        query: { links_to_asset: id },
+    });
+    return entries;
+};
 export const isContentfulObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).includes('sys');
 export const isLink = (obj) => isContentfulObject(obj) && obj.sys.type === FIELD_TYPE_LINK;
 export const isAssetLink = (obj) => isLink(obj) && obj.sys.linkType === LINK_TYPE_ASSET;

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+declare module 'http' {
+    interface IncomingHttpHeaders {
+        'x-contentful-topic': 'ContentManagement.ContentType.create' | 'ContentManagement.ContentType.save' | 'ContentManagement.ContentType.publish' | 'ContentManagement.ContentType.unpublish' | 'ContentManagement.ContentType.delete' | 'ContentManagement.Entry.create' | 'ContentManagement.Entry.save' | 'ContentManagement.Entry.auto_save' | 'ContentManagement.Entry.archive' | 'ContentManagement.Entry.unarchive' | 'ContentManagement.Entry.publish' | 'ContentManagement.Entry.unpublish' | 'ContentManagement.Entry.delete' | 'ContentManagement.Asset.create' | 'ContentManagement.Asset.save' | 'ContentManagement.Asset.auto_save' | 'ContentManagement.Asset.archive' | 'ContentManagement.Asset.unarchive' | 'ContentManagement.Asset.publish' | 'ContentManagement.Asset.unpublish' | 'ContentManagement.Asset.delete';
+        'X-Contentful-Webhook-Name': string;
+    }
+}
+export declare const getApp: (callback: () => Promise<void>) => import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -0,0 +1,29 @@
+import express from 'express';
+const app = express();
+app.disable('x-powered-by');
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json({
+    type: [
+        'application/vnd.contentful.management.v1+json',
+        'application/vnd.contentful.management.v1+json; charset=utf-8',
+        'application/json',
+        'application/json; charset=utf-8',
+        'application/x-www-form-urlencoded',
+        'application/x-www-form-urlencoded; charset=utf-8',
+    ],
+}));
+export const getApp = (callback) => {
+    app.get('/status', (_req, res) => res.status(200).send('ok'));
+    app.get('/', async (_req, res) => {
+        await callback();
+        return res.status(200).send('ok');
+    });
+    app.post('/', async (req, res) => {
+        if (!req.body.sys) {
+            return res.status(401).send('error');
+        }
+        await callback();
+        return res.status(200).send('ok');
+    });
+    return app;
+};

package/dist/tasks/fetch.js

@@ -1,7 +1,13 @@
-import { getContent, getFieldSettings } from '../lib/contentful.js';
+import { getContent, getFieldSettings, getEntriesLinkedToEntry, getEntriesLinkedToAsset, } from '../lib/contentful.js';
 export const fetch = async (context, config) => {
     const content = await getContent(config);
     const { locales, contentTypes } = content;
+    const additionalEntriesPromise = [
+        ...(content?.deletedEntries?.map(async (entry) => getEntriesLinkedToEntry(config, entry.sys.id)) ?? []),
+        ...(content?.deletedAssets?.map(async (asset) => getEntriesLinkedToAsset(config, asset.sys.id)) ?? []),
+    ];
+    const additionalEntries = (await Promise.all(additionalEntriesPromise)).flat();
+    content.entries = [...(content?.entries ?? []), ...additionalEntries];
     const fieldSettings = getFieldSettings(contentTypes);
     const { code: defaultLocale } = locales.find((locale) => locale.default);
     context.defaultLocale = defaultLocale;

package/dist/tasks/remove.d.ts

@@ -0,0 +1,2 @@
+import { TransformContext, RuntimeContext, Config } from '../types';
+export declare const remove: (transformContext: TransformContext, runtimeContext: RuntimeContext, config: Config) => Promise<void>;

package/dist/tasks/remove.js

@@ -0,0 +1,5 @@
+import { getFilepath } from './write.js';
+export const remove = async (transformContext, runtimeContext, config) => {
+    const filepath = await getFilepath(transformContext, runtimeContext, config);
+    await runtimeContext.fileManager.deleteFile(filepath);
+};

package/dist/tasks/write.d.ts

@@ -1,2 +1,4 @@
 import type { TransformContext, RuntimeContext, Config } from '../types.js';
+export declare const getFormat: (transformContext: TransformContext, runtimeContext: RuntimeContext, config: Config) => Promise<string>;
+export declare const getFilepath: (transformContext: TransformContext, runtimeContext: RuntimeContext, config: Config) => Promise<string>;
 export declare const write: (transformContext: TransformContext, runtimeContext: RuntimeContext, config: Config) => Promise<void>;