@jungvonmatt/contentful-fakes 1.4.0

package/.env

@@ -0,0 +1,3 @@
+CONTENTFUL_SPACE_ID=gpdredy5px7h
+CONTENTFUL_DELIVERY_TOKEN=e80ac10a81330387c6676abf6388fdee8814ccb9480e057c587b855dfd7b6beb
+CONTENTFUL_PREVIEW_TOKEN=a3651d3c90791271f75cbb5387df8d23648d7905a29160bc0e7626c8ed0b6e8e

package/.eslintrc.cjs

@@ -0,0 +1,16 @@
+module.exports = {
+  root: true,
+  plugins: ['prettier'],
+  extends: ['xo', 'xo-typescript/space', 'plugin:prettier/recommended'],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: ['./tsconfig.json'],
+    tsconfigRootDir: __dirname,
+    extraFileExtensions: ['.cjs'],
+  },
+  ignorePatterns: ['**/*.cjs', 'src/**/*.test.ts', 'src/__test__/*'],
+  env: {
+    node: true,
+    jest: true,
+  }
+};

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [1.4.0](https://github.com/jungvonmatt/contentful-ssg/compare/v1.3.2...v1.4.0) (2022-01-19)
+
+
+### Features
+
+* 🎸 Adds new contentful-fakes package ([bb67694](https://github.com/jungvonmatt/contentful-ssg/commit/bb676946532281864c6355f294e984f792f9cfa3))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jung von Matt TECH (https://www.jvm.com/)
+
+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,40 @@
+[![NPM version][npm-image]][npm-url]
+
+# JvM Contentful fake data generator
+
+Generate fake data files based on your Contentful content models
+
+## Getting started
+
+### Install
+
+```bash
+npm install --save-dev @jungvonmatt/contentful-fakes
+```
+
+## Commands
+
+### help
+
+```bash
+npx contentful-fakes help [command]
+```
+
+### create
+
+Fetch all content entries and store them as yaml in the configured directory
+
+```bash
+npx contentful-fakes create [options]
+```
+
+#### options
+
+```
+  -c, --content-type` `<content-type...>  Specify content-types
+  -e, --extension <extension>           Specify output format (default: "yaml")
+  -o, --output-directory <directory>    Specify output directory (default: "data")
+```
+
+[npm-url]: https://www.npmjs.com/package/@jungvonmatt/contentful-fakes
+[npm-image]: https://img.shields.io/npm/v/@jungvonmatt/contentful-fakes.svg

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import path from 'path';
+import { existsSync } from 'fs';
+import { outputFile } from 'fs-extra';
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import dotenvExpand from 'dotenv-expand';
+import { getConfig } from '@jungvonmatt/contentful-ssg/lib/config';
+import { forEachAsync } from '@jungvonmatt/contentful-ssg/lib/array';
+import { stringify } from '@jungvonmatt/contentful-ssg/converter';
+import { logError, askMissing, confirm } from '@jungvonmatt/contentful-ssg/lib/ui';
+import { createFakes } from './index.js';
+const env = dotenv.config();
+dotenvExpand(env);
+const parseArgs = (cmd) => ({
+    environment: cmd.env,
+    verbose: Boolean(cmd.verbose),
+    contentTypes: cmd.contentType,
+});
+const errorHandler = (error, silence) => {
+    if (!silence) {
+        const { errors } = error;
+        logError(error);
+        (errors || []).forEach((error) => {
+            logError(error);
+        });
+    }
+    process.exit(1);
+};
+const actionRunner = (fn, log = true) => (...args) => fn(...args).catch((error) => errorHandler(error, !log));
+const program = new Command();
+program
+    .command('create')
+    .description('Create fake objects')
+    .option('-c, --content-type <content-type...>', 'Specify content-types')
+    .option('-e, --extension <extension>', 'Specify output format', 'yaml')
+    .option('-o, --output-directory <directory>', 'Specify output directory', 'data')
+    .option('-f, --force', 'Overwrite')
+    .action(actionRunner(async (cmd) => {
+    const contentTypes = cmd?.contentType ?? [];
+    const force = cmd?.force ?? false;
+    const format = cmd?.extension ?? '';
+    const outputDirectory = cmd?.outputDirectory ?? '';
+    const config = await getConfig(parseArgs(cmd));
+    const verified = await askMissing(config);
+    const fakes = await createFakes(verified, contentTypes);
+    await forEachAsync(Object.entries(fakes), async ([contentTypeId, fakeData]) => {
+        const [defaultData, minData] = fakeData;
+        const dir = path.join(outputDirectory, contentTypeId);
+        const filenameDefault = path.join(dir, `default.${format}`);
+        const filenameMin = path.join(dir, `min.${format}`);
+        if (!existsSync(filenameDefault) ||
+            force ||
+            (await confirm(`Overwrite file: ${filenameDefault}`))) {
+            await outputFile(filenameDefault, stringify(defaultData, format));
+        }
+        if (!existsSync(filenameMin) ||
+            force ||
+            (await confirm(`Overwrite file: ${filenameMin}`))) {
+            await outputFile(filenameMin, stringify(minData, format));
+        }
+    });
+}));
+program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { ContentfulConfig, KeyValueMap } from '@jungvonmatt/contentful-ssg';
+export declare function createFakes(config: ContentfulConfig, contentTypeIds: string[]): Promise<Record<string, KeyValueMap[]>>;

package/dist/index.js

@@ -0,0 +1,27 @@
+import { getEnvironment } from '@jungvonmatt/contentful-ssg/lib/contentful';
+import { getMockData } from './lib/faker.js';
+export async function createFakes(config, contentTypeIds) {
+    const environment = await getEnvironment(config);
+    const { items: contentTypes } = await environment.getContentTypes();
+    const { items } = await environment.getEditorInterfaces();
+    const interfaces = Object.fromEntries(items
+        .filter((item) => !contentTypeIds.length || contentTypeIds.includes(item.sys.contentType.sys.id))
+        .map((item) => {
+        const { id } = item.sys.contentType.sys;
+        const contentType = contentTypes.find((ct) => ct.sys.id === id);
+        const { controls } = item;
+        const fields = controls.map((control) => {
+            const { fieldId } = control;
+            const fieldSettings = contentType.fields.find((field) => field.id === fieldId);
+            return { interface: control, settings: fieldSettings };
+        });
+        return [id, fields];
+    }));
+    const data = await getMockData(interfaces);
+    return Object.fromEntries(Object.entries(interfaces).map(([contentTypeId, fields]) => {
+        const { [contentTypeId]: fakeData = {} } = data;
+        const required = Object.fromEntries(fields.map((field) => [field.settings.id, field.settings.required]));
+        const minData = Object.fromEntries(Object.entries(fakeData).filter(([fieldId]) => required?.[fieldId]));
+        return [contentTypeId, [fakeData, minData]];
+    }));
+}

package/dist/lib/faker.d.ts

@@ -0,0 +1,8 @@
+import { ContentFields, KeyValueMap, Control } from 'contentful-management/types';
+export declare type FieldInfo = {
+    interface: Control;
+    settings: Partial<ContentFields>;
+};
+export declare type ContentTypes = Record<string, FieldInfo[]>;
+export declare const getMockData: (contentTypes: ContentTypes) => Promise<KeyValueMap>;
+export declare const createData: (fields: FieldInfo[]) => Promise<KeyValueMap>;

package/dist/lib/faker.js

@@ -0,0 +1,318 @@
+import { FIELD_TYPE_SYMBOL, FIELD_TYPE_TEXT, FIELD_TYPE_RICHTEXT, FIELD_TYPE_NUMBER, FIELD_TYPE_INTEGER, FIELD_TYPE_DATE, FIELD_TYPE_LOCATION, FIELD_TYPE_ARRAY, FIELD_TYPE_BOOLEAN, FIELD_TYPE_LINK, FIELD_TYPE_OBJECT, LINK_TYPE_ASSET, LINK_TYPE_ENTRY, } from '@jungvonmatt/contentful-ssg/lib/contentful';
+import faker from 'faker';
+import casual from 'casual';
+import RandExp from 'randexp';
+import { oneOf, randomInt } from './helper.js';
+export const getMockData = async (contentTypes) => {
+    const dataEntries = await Promise.all(Object.entries(contentTypes).map(async ([name, fields]) => [name, await createData(fields)]));
+    return Object.fromEntries(dataEntries);
+};
+export const createData = async (fields) => {
+    const entries = await Promise.all(fields.map(async (field) => {
+        const id = field?.settings?.id || 'undefined';
+        switch (field.settings.type) {
+            case FIELD_TYPE_SYMBOL:
+                return [id, await getSymbolFake(field)];
+            case FIELD_TYPE_INTEGER:
+                return [id, await getIntegerFake(field)];
+            case FIELD_TYPE_NUMBER:
+                return [id, await getNumberFake(field)];
+            case FIELD_TYPE_TEXT:
+                return [id, await getTextFake(field)];
+            case FIELD_TYPE_LINK:
+                return [id, await getLinkFake(field)];
+            case FIELD_TYPE_ARRAY:
+                return [id, await getArrayFake(field)];
+            case FIELD_TYPE_BOOLEAN:
+                return [id, faker.datatype.boolean()];
+            case FIELD_TYPE_DATE:
+                return [id, faker.date.future()];
+            case FIELD_TYPE_RICHTEXT:
+                return [id, await getRichtextFake(field)];
+            case FIELD_TYPE_OBJECT:
+                return [id, {}];
+            case FIELD_TYPE_LOCATION:
+                return [
+                    id,
+                    {
+                        lat: faker.address.latitude(),
+                        lng: faker.address.longitude(),
+                    },
+                ];
+            default:
+                return [id, undefined];
+        }
+    }));
+    return Object.fromEntries(entries);
+};
+const getRegexValue = (regex) => {
+    const { pattern, flags } = regex;
+    if (pattern === '^\\w[\\w.-]*@([\\w-]+\\.)+[\\w-]+$') {
+        return faker.internet.exampleEmail();
+    }
+    if (pattern.includes('\\/\\/(\\w+:{0,1}\\w*@)?(\\S+)(:[0-9]+)?(\\/|\\/([\\w#!:.?+=&%@!\\-/]))?$')) {
+        return faker.internet.url();
+    }
+    if (pattern === '^(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?\\d\\d$') {
+        return casual.time('MM-DD-YYYY');
+    }
+    if (pattern === '^(0?[1-9]|[12][0-9]|3[01])[- /.](0?[1-9]|1[012])[- /.](19|20)?\\d\\d$') {
+        return casual.time('DD-MM-YYYY');
+    }
+    if (pattern === '^(0?[1-9]|1[012]):[0-5][0-9](:[0-5][0-9])?\\s*[aApP][mM]$') {
+        return casual.time('hh:mm a');
+    }
+    if (pattern === '^(0?[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$') {
+        return casual.time('HH:mm');
+    }
+    if (pattern === '^\\d[ -.]?\\(?\\d\\d\\d\\)?[ -.]?\\d\\d\\d[ -.]?\\d\\d\\d\\d$') {
+        return faker.phone.phoneNumber();
+    }
+    if (pattern === '^\\d{5}$|^\\d{5}-\\d{4}$}') {
+        return faker.address.zipCode();
+    }
+    return new RandExp(pattern, flags);
+};
+const getTextForId = (id) => {
+    if ([
+        'username',
+        'first_name',
+        'last_name',
+        'full_name',
+        'password',
+        'name_prefix',
+        'name_suffix',
+        'company_name',
+        'company_suffix',
+        'catch_phrase',
+        'phone',
+        'ip',
+        'domain',
+        'url',
+        'email',
+        'user_agent',
+        'country',
+        'city',
+        'zip',
+        'street',
+        'address',
+        'address1',
+        'address2',
+        'state',
+        'state_abbr',
+        'latitude',
+        'longitude',
+        'building_number',
+    ].includes(id)) {
+        return casual?.[id]() ?? faker.lorem.word();
+    }
+    if (['uuid', 'uid', 'id'].includes(id)) {
+        return casual.uuid;
+    }
+    return undefined;
+};
+const getIntegerFake = async (field) => {
+    return getNumberFake(field, 1);
+};
+const getNumberFake = async (field, precision = 0.005) => {
+    const { validations = [] } = field.settings;
+    const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+    if (values) {
+        return oneOf(values);
+    }
+    const { range } = validations.find((validation) => Boolean(validation?.range)) || {};
+    if (range) {
+        const { min, max } = range;
+        if (typeof min !== 'undefined' && typeof max !== 'undefined') {
+            return faker.datatype.number({ min, max, precision });
+        }
+        if (typeof min !== 'undefined') {
+            return faker.datatype.number({ min, precision });
+        }
+        if (typeof max !== 'undefined') {
+            return faker.datatype.number({ max, precision });
+        }
+    }
+    return faker.datatype.number({ precision });
+};
+const getSymbolFake = async (field) => {
+    const { widgetId } = field.interface;
+    const { validations = [], id } = field.settings;
+    const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+    if (values) {
+        return oneOf(values);
+    }
+    let result = '';
+    if (widgetId === 'urlEditor') {
+        result = faker.internet.url();
+    }
+    if (widgetId === 'slugEditor') {
+        result = faker.lorem.slug();
+    }
+    const byId = getTextForId(id);
+    if (!result && byId) {
+        return byId;
+    }
+    if (!result && ['dropdown', 'radio'].includes(widgetId)) {
+        result = faker.lorem.word();
+    }
+    const { regexp } = validations.find((validation) => Boolean(validation?.regexp)) || {};
+    if (!result && regexp) {
+        result = getRegexValue(regexp);
+    }
+    if (!result) {
+        result = faker.lorem.sentence();
+    }
+    const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+    if (size) {
+        const { min = 0, max = 255 } = size;
+        const count = randomInt(min, max);
+        result = result.slice(0, count);
+    }
+    return result;
+};
+const getTextFake = async (field) => {
+    const { validations = [], id } = field.settings;
+    const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+    let result = '';
+    if (values) {
+        result = oneOf(values);
+    }
+    const byId = getTextForId(id);
+    if (!result && byId) {
+        result = byId;
+    }
+    const { regexp } = validations.find((validation) => Boolean(validation?.regexp)) || {};
+    if (!result && regexp) {
+        result = getRegexValue(regexp);
+    }
+    if (!result) {
+        result = faker.lorem.lines();
+    }
+    const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+    if (size) {
+        const { min = 0, max = 50000 } = size;
+        const count = randomInt(min, max);
+        result = result.slice(0, count);
+    }
+    return result;
+};
+const getAssetFake = async () => {
+    const sizes = [640, 480, 600, 800, 1024];
+    const width = oneOf(sizes);
+    const height = oneOf(sizes);
+    return {
+        mime_type: 'image/jpeg',
+        url: faker.image.image(width, height),
+        title: faker.lorem.words(),
+        description: faker.lorem.lines(),
+        width,
+        height,
+        file_size: faker.datatype.number({ min: 1000, max: 200000 }),
+    };
+};
+const getEntryScheme = async (field) => {
+    const { validations } = field.settings;
+    const { linkContentType = [] } = validations.find((validation) => Boolean(validation?.linkContentType)) || {};
+    if (linkContentType.length > 0) {
+        return {
+            id: 'default',
+            content_type: oneOf(linkContentType),
+        };
+    }
+    return {};
+};
+const getLinkFake = async (field) => {
+    if (field?.settings?.linkType === LINK_TYPE_ASSET) {
+        return getAssetFake();
+    }
+    return getEntryScheme(field);
+};
+const getRichtextFake = async (field) => {
+    const { validations } = field.settings;
+    const { enabledMarks: marks = [] } = validations.find((validation) => Boolean(validation?.enabledMarks)) || {};
+    const { enabledNodeTypes: nodeTypes = [] } = validations.find((validation) => Boolean(validation?.enabledNodeTypes)) || {};
+    return {
+        node_type: 'document',
+        data: {},
+        content: [
+            ...nodeTypes
+                .filter((nodeType) => nodeType.startsWith('heading'))
+                .map((nodeType) => ({
+                node_type: nodeType,
+                content: [
+                    {
+                        node_type: 'text',
+                        value: nodeType,
+                        marks: [],
+                        data: {},
+                    },
+                ],
+                data: {},
+            })),
+            ...marks.map((mark) => ({
+                node_type: 'paragraph',
+                content: [
+                    {
+                        node_type: 'text',
+                        value: mark,
+                        marks: [mark],
+                        data: {},
+                    },
+                ],
+                data: {},
+            })),
+            {
+                node_type: 'paragraph',
+                content: [
+                    {
+                        node_type: 'text',
+                        value: faker.lorem.sentence(),
+                        marks: [],
+                        data: {},
+                    },
+                ],
+                data: {},
+            },
+        ],
+    };
+};
+const getArrayFake = async (field) => {
+    const { validations } = field.settings;
+    const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+    let count = randomInt(0, 10);
+    if (size) {
+        count = randomInt(size?.min ?? 0, size?.max ?? (size?.min ?? 0) + 10);
+    }
+    if (field.settings.items.type === FIELD_TYPE_SYMBOL) {
+        return Promise.all(Array(count)
+            .fill('')
+            .map(async () => getSymbolFake({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+        })));
+    }
+    if (field.settings.items.type === FIELD_TYPE_TEXT) {
+        return Promise.all(Array(count)
+            .fill('')
+            .map(async () => getTextFake({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+        })));
+    }
+    if (field.settings.items.type === FIELD_TYPE_LINK &&
+        field.settings.items.linkType === LINK_TYPE_ASSET) {
+        return Promise.all(Array(count)
+            .fill('')
+            .map(async () => getAssetFake()));
+    }
+    if (field.settings.items.type === FIELD_TYPE_LINK &&
+        field.settings.items.linkType === LINK_TYPE_ENTRY) {
+        return Promise.all(Array(count)
+            .fill('')
+            .map(async () => getEntryScheme({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+        })));
+    }
+};

package/dist/lib/helper.d.ts

@@ -0,0 +1,2 @@
+export declare const oneOf: <T = string>(array?: T[]) => T;
+export declare const randomInt: (min?: number, max?: number) => number;

package/dist/lib/helper.js

@@ -0,0 +1,9 @@
+export const oneOf = (array = []) => {
+    const index = randomInt(0, array.length);
+    return array[index];
+};
+export const randomInt = (min = 0, max = 1000000) => {
+    min = Math.ceil(min || 0);
+    max = Math.floor(max || 1000000);
+    return Math.floor(Math.random() * (max - min)) + min;
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@jungvonmatt/contentful-fakes",
+  "version": "1.4.0",
+  "description": "Create fake data based on contentful data models",
+  "main": "./dist/index.js",
+  "type": "module",
+  "typings": "./dist/types.d.ts",
+  "bin": {
+    "contentful-fakes": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "lint": "eslint --color src --fix --ext .ts",
+    "precompile": "npm run clean",
+    "compile": "tsc --build",
+    "postcompile": "chmod +x ./dist/cli.js",
+    "watch": "tsc --build --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jungvonmatt/contentful-ssg.git"
+  },
+  "keywords": [
+    "fake",
+    "data",
+    "contentful"
+  ],
+  "author": "Ben Zörb",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jungvonmatt/contentful-ssg/issues"
+  },
+  "homepage": "https://github.com/jungvonmatt/contentful-ssg#readme",
+  "dependencies": {
+    "@jungvonmatt/contentful-ssg": "^1.4.0",
+    "casual": "^1.6.2",
+    "faker": "^5.5.3",
+    "fs-extra": "^10.0.0",
+    "randexp": "^0.5.3"
+  },
+  "devDependencies": {
+    "@types/chance": "^1.1.3",
+    "@types/faker": "^6.6.9"
+  },
+  "gitHead": "0d323f9884ae8fa48049e25bcd127954ee7988b8"
+}

package/src/cli.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/* eslint-env node */
+import path from 'path';
+import { existsSync } from 'fs';
+import { outputFile } from 'fs-extra';
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import dotenvExpand from 'dotenv-expand';
+import { ContentfulConfig } from '@jungvonmatt/contentful-ssg';
+import { getConfig } from '@jungvonmatt/contentful-ssg/lib/config';
+import { forEachAsync } from '@jungvonmatt/contentful-ssg/lib/array';
+import { stringify } from '@jungvonmatt/contentful-ssg/converter';
+import { logError, askMissing, confirm } from '@jungvonmatt/contentful-ssg/lib/ui';
+import { createFakes } from './index.js';
+
+const env = dotenv.config();
+dotenvExpand(env);
+
+type CommandArgs = {
+  outputDirectory: string;
+  extension: string;
+  contentType: string[];
+  env: string;
+  verbose: boolean;
+  force: boolean;
+};
+
+const parseArgs = (cmd: CommandArgs) => ({
+  environment: cmd.env,
+  verbose: Boolean(cmd.verbose),
+  contentTypes: cmd.contentType,
+});
+
+type CommandError = Error & {
+  errors?: Error[];
+};
+const errorHandler = (error: CommandError, silence: boolean) => {
+  if (!silence) {
+    const { errors } = error;
+    logError(error);
+    (errors || []).forEach((error) => {
+      logError(error);
+    });
+  }
+
+  process.exit(1);
+};
+
+const actionRunner =
+  (fn, log = true) =>
+  (...args) =>
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+    fn(...args).catch((error) => errorHandler(error, !log));
+const program = new Command();
+
+program
+  .command('create')
+  .description('Create fake objects')
+  .option('-c, --content-type <content-type...>', 'Specify content-types')
+  .option('-e, --extension <extension>', 'Specify output format', 'yaml')
+  .option('-o, --output-directory <directory>', 'Specify output directory', 'data')
+  .option('-f, --force', 'Overwrite')
+  .action(
+    actionRunner(async (cmd: CommandArgs) => {
+      const contentTypes: string[] = cmd?.contentType ?? [];
+      const force: boolean = cmd?.force ?? false;
+      const format: string = cmd?.extension ?? '';
+      const outputDirectory: string = cmd?.outputDirectory ?? '';
+      const config = await getConfig(parseArgs(cmd));
+      const verified = await askMissing(config);
+      const fakes = await createFakes(verified as ContentfulConfig, contentTypes);
+      await forEachAsync(Object.entries(fakes), async ([contentTypeId, fakeData]) => {
+        const [defaultData, minData] = fakeData;
+        const dir = path.join(outputDirectory, contentTypeId);
+        const filenameDefault = path.join(dir, `default.${format}`);
+        const filenameMin = path.join(dir, `min.${format}`);
+        if (
+          !existsSync(filenameDefault) ||
+          force ||
+          (await confirm(`Overwrite file: ${filenameDefault}`))
+        ) {
+          await outputFile(filenameDefault, stringify(defaultData, format));
+        }
+
+        if (
+          !existsSync(filenameMin) ||
+          force ||
+          (await confirm(`Overwrite file: ${filenameMin}`))
+        ) {
+          await outputFile(filenameMin, stringify(minData, format));
+        }
+      });
+    })
+  );
+
+program.parse(process.argv);

package/src/index.ts

@@ -0,0 +1,47 @@
+import { ContentfulConfig, KeyValueMap } from '@jungvonmatt/contentful-ssg';
+import { getEnvironment } from '@jungvonmatt/contentful-ssg/lib/contentful';
+import { getMockData, ContentTypes } from './lib/faker.js';
+
+export async function createFakes(
+  config: ContentfulConfig,
+  contentTypeIds: string[]
+): Promise<Record<string, KeyValueMap[]>> {
+  const environment = await getEnvironment(config);
+  const { items: contentTypes } = await environment.getContentTypes();
+  const { items } = await environment.getEditorInterfaces();
+
+  const interfaces: ContentTypes = Object.fromEntries(
+    items
+      .filter(
+        (item) => !contentTypeIds.length || contentTypeIds.includes(item.sys.contentType.sys.id)
+      )
+      .map((item) => {
+        const { id } = item.sys.contentType.sys;
+        const contentType = contentTypes.find((ct) => ct.sys.id === id);
+        const { controls } = item;
+
+        const fields = controls.map((control) => {
+          const { fieldId } = control;
+          const fieldSettings = contentType.fields.find((field) => field.id === fieldId);
+          return { interface: control, settings: fieldSettings };
+        });
+        return [id, fields];
+      })
+  );
+
+  const data = await getMockData(interfaces);
+
+  return Object.fromEntries(
+    Object.entries(interfaces).map(([contentTypeId, fields]) => {
+      const { [contentTypeId]: fakeData = {} } = data;
+      const required = Object.fromEntries(
+        fields.map((field) => [field.settings.id, field.settings.required])
+      );
+
+      const minData = Object.fromEntries(
+        Object.entries(fakeData).filter(([fieldId]) => required?.[fieldId])
+      );
+      return [contentTypeId, [fakeData, minData]];
+    })
+  );
+}

package/src/lib/faker.ts

@@ -0,0 +1,451 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/naming-convention */
+// See validations
+// https://www.contentful.com/developers/docs/references/content-management-api/#/reference/content-types/content-type
+
+import {
+  FIELD_TYPE_SYMBOL,
+  FIELD_TYPE_TEXT,
+  FIELD_TYPE_RICHTEXT,
+  FIELD_TYPE_NUMBER,
+  FIELD_TYPE_INTEGER,
+  FIELD_TYPE_DATE,
+  FIELD_TYPE_LOCATION,
+  FIELD_TYPE_ARRAY,
+  FIELD_TYPE_BOOLEAN,
+  FIELD_TYPE_LINK,
+  FIELD_TYPE_OBJECT,
+  LINK_TYPE_ASSET,
+  LINK_TYPE_ENTRY,
+} from '@jungvonmatt/contentful-ssg/lib/contentful';
+
+import { ContentFields, KeyValueMap, Control } from 'contentful-management/types';
+
+import faker from 'faker';
+import casual from 'casual';
+import RandExp from 'randexp';
+import { oneOf, randomInt } from './helper.js';
+
+export type FieldInfo = {
+  interface: Control;
+  settings: Partial<ContentFields>;
+};
+
+export type ContentTypes = Record<string, FieldInfo[]>;
+
+export const getMockData = async (contentTypes: ContentTypes): Promise<KeyValueMap> => {
+  const dataEntries = await Promise.all(
+    Object.entries(contentTypes).map(async ([name, fields]) => [name, await createData(fields)])
+  );
+
+  return Object.fromEntries(dataEntries);
+};
+
+export const createData = async (fields: FieldInfo[]): Promise<KeyValueMap> => {
+  const entries = await Promise.all(
+    fields.map(async (field) => {
+      const id = field?.settings?.id || 'undefined';
+      switch (field.settings.type) {
+        case FIELD_TYPE_SYMBOL:
+          return [id, await getSymbolFake(field)];
+        case FIELD_TYPE_INTEGER:
+          return [id, await getIntegerFake(field)];
+        case FIELD_TYPE_NUMBER:
+          return [id, await getNumberFake(field)];
+        case FIELD_TYPE_TEXT:
+          return [id, await getTextFake(field)];
+        case FIELD_TYPE_LINK:
+          return [id, await getLinkFake(field)];
+        case FIELD_TYPE_ARRAY:
+          return [id, await getArrayFake(field)];
+        case FIELD_TYPE_BOOLEAN:
+          return [id, faker.datatype.boolean()];
+        case FIELD_TYPE_DATE:
+          return [id, faker.date.future()];
+        case FIELD_TYPE_RICHTEXT:
+          return [id, await getRichtextFake(field)];
+        case FIELD_TYPE_OBJECT:
+          return [id, {}];
+        case FIELD_TYPE_LOCATION:
+          return [
+            id,
+            {
+              lat: faker.address.latitude(),
+              lng: faker.address.longitude(),
+            },
+          ];
+        default:
+          return [id, undefined];
+      }
+    })
+  );
+
+  return Object.fromEntries(entries);
+};
+
+type RegexType = {
+  pattern: string;
+  flags: string;
+};
+
+const getRegexValue = (regex: RegexType) => {
+  const { pattern, flags } = regex;
+
+  // First try to handle regex values predefined in contentful
+  // Email:
+  if (pattern === '^\\w[\\w.-]*@([\\w-]+\\.)+[\\w-]+$') {
+    return faker.internet.exampleEmail();
+  }
+
+  // Url:
+  if (
+    pattern.includes('\\/\\/(\\w+:{0,1}\\w*@)?(\\S+)(:[0-9]+)?(\\/|\\/([\\w#!:.?+=&%@!\\-/]))?$')
+  ) {
+    return faker.internet.url();
+  }
+
+  // Date (US)
+  if (pattern === '^(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?\\d\\d$') {
+    return casual.time('MM-DD-YYYY');
+  }
+
+  // Date (European)
+  if (pattern === '^(0?[1-9]|[12][0-9]|3[01])[- /.](0?[1-9]|1[012])[- /.](19|20)?\\d\\d$') {
+    return casual.time('DD-MM-YYYY');
+  }
+
+  // 12h Time
+  if (pattern === '^(0?[1-9]|1[012]):[0-5][0-9](:[0-5][0-9])?\\s*[aApP][mM]$') {
+    return casual.time('hh:mm a');
+  }
+
+  // 24h time
+  if (pattern === '^(0?[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$') {
+    return casual.time('HH:mm');
+  }
+
+  // US Phone number
+  if (pattern === '^\\d[ -.]?\\(?\\d\\d\\d\\)?[ -.]?\\d\\d\\d[ -.]?\\d\\d\\d\\d$') {
+    return faker.phone.phoneNumber();
+  }
+
+  // US Zip code
+  if (pattern === '^\\d{5}$|^\\d{5}-\\d{4}$}') {
+    return faker.address.zipCode();
+  }
+
+  return new RandExp(pattern, flags);
+};
+
+const getTextForId = (id: string) => {
+  if (
+    [
+      'username',
+      'first_name',
+      'last_name',
+      'full_name',
+      'password',
+      'name_prefix',
+      'name_suffix',
+      'company_name',
+      'company_suffix',
+      'catch_phrase',
+      'phone',
+      'ip',
+      'domain',
+      'url',
+      'email',
+      'user_agent',
+      'country',
+      'city',
+      'zip',
+      'street',
+      'address',
+      'address1',
+      'address2',
+      'state',
+      'state_abbr',
+      'latitude',
+      'longitude',
+      'building_number',
+    ].includes(id)
+  ) {
+    return casual?.[id]() ?? faker.lorem.word();
+  }
+
+  if (['uuid', 'uid', 'id'].includes(id)) {
+    return casual.uuid;
+  }
+
+  return undefined;
+};
+
+const getIntegerFake = async (field: FieldInfo): Promise<unknown> => {
+  return getNumberFake(field, 1);
+};
+
+const getNumberFake = async (field: FieldInfo, precision = 0.005): Promise<unknown> => {
+  const { validations = [] } = field.settings;
+
+  const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+  if (values) {
+    return oneOf(values);
+  }
+
+  const { range } = validations.find((validation) => Boolean(validation?.range)) || {};
+  if (range) {
+    const { min, max } = range;
+    if (typeof min !== 'undefined' && typeof max !== 'undefined') {
+      return faker.datatype.number({ min, max, precision });
+    }
+
+    if (typeof min !== 'undefined') {
+      return faker.datatype.number({ min, precision });
+    }
+
+    if (typeof max !== 'undefined') {
+      return faker.datatype.number({ max, precision });
+    }
+  }
+
+  return faker.datatype.number({ precision });
+};
+
+const getSymbolFake = async (field: FieldInfo): Promise<unknown> => {
+  const { widgetId } = field.interface;
+  const { validations = [], id } = field.settings;
+
+  const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+  if (values) {
+    return oneOf(values);
+  }
+
+  let result = '';
+
+  if (widgetId === 'urlEditor') {
+    result = faker.internet.url();
+  }
+
+  if (widgetId === 'slugEditor') {
+    result = faker.lorem.slug();
+  }
+
+  const byId = getTextForId(id);
+  if (!result && byId) {
+    return byId;
+  }
+
+  if (!result && ['dropdown', 'radio'].includes(widgetId)) {
+    result = faker.lorem.word();
+  }
+
+  const { regexp } = validations.find((validation) => Boolean(validation?.regexp)) || {};
+  if (!result && regexp) {
+    result = getRegexValue(regexp);
+  }
+
+  if (!result) {
+    result = faker.lorem.sentence();
+  }
+
+  const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+  if (size) {
+    const { min = 0, max = 255 } = size;
+    const count = randomInt(min, max);
+    result = result.slice(0, count);
+  }
+
+  return result;
+};
+
+const getTextFake = async (field: FieldInfo): Promise<unknown> => {
+  const { validations = [], id } = field.settings;
+  const { in: values } = validations.find((validation) => Boolean(validation?.in)) || {};
+
+  let result = '';
+  if (values) {
+    result = oneOf(values as string[]);
+  }
+
+  const byId = getTextForId(id);
+  if (!result && byId) {
+    result = byId;
+  }
+
+  const { regexp } = validations.find((validation) => Boolean(validation?.regexp)) || {};
+  if (!result && regexp) {
+    result = getRegexValue(regexp);
+  }
+
+  if (!result) {
+    result = faker.lorem.lines();
+  }
+
+  const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+  if (size) {
+    const { min = 0, max = 50000 } = size;
+    const count = randomInt(min, max);
+    result = result.slice(0, count);
+  }
+
+  return result;
+};
+
+const getAssetFake = async (): Promise<KeyValueMap> => {
+  const sizes = [640, 480, 600, 800, 1024];
+  const width = oneOf(sizes);
+  const height = oneOf(sizes);
+
+  return {
+    mime_type: 'image/jpeg',
+    url: faker.image.image(width, height),
+    title: faker.lorem.words(),
+    description: faker.lorem.lines(),
+    width,
+    height,
+    file_size: faker.datatype.number({ min: 1000, max: 200000 }),
+  };
+};
+
+const getEntryScheme = async (field: FieldInfo): Promise<KeyValueMap> => {
+  const { validations } = field.settings;
+
+  const { linkContentType = [] } =
+    validations.find((validation) => Boolean(validation?.linkContentType)) || {};
+
+  if (linkContentType.length > 0) {
+    return {
+      id: 'default',
+      content_type: oneOf(linkContentType),
+    };
+  }
+
+  return {};
+};
+
+const getLinkFake = async (field: FieldInfo): Promise<KeyValueMap> => {
+  if (field?.settings?.linkType === LINK_TYPE_ASSET) {
+    return getAssetFake();
+  }
+
+  return getEntryScheme(field);
+};
+
+const getRichtextFake = async (field: FieldInfo): Promise<KeyValueMap> => {
+  const { validations } = field.settings;
+
+  const { enabledMarks: marks = [] } =
+    validations.find((validation) => Boolean(validation?.enabledMarks)) || {};
+
+  const { enabledNodeTypes: nodeTypes = [] } =
+    validations.find((validation) => Boolean(validation?.enabledNodeTypes)) || {};
+
+  return {
+    node_type: 'document',
+    data: {},
+    content: [
+      ...nodeTypes
+        .filter((nodeType) => nodeType.startsWith('heading'))
+        .map((nodeType) => ({
+          node_type: nodeType,
+          content: [
+            {
+              node_type: 'text',
+              value: nodeType,
+              marks: [],
+              data: {},
+            },
+          ],
+          data: {},
+        })),
+      ...marks.map((mark) => ({
+        node_type: 'paragraph',
+        content: [
+          {
+            node_type: 'text',
+            value: mark,
+            marks: [mark],
+            data: {},
+          },
+        ],
+        data: {},
+      })),
+      {
+        node_type: 'paragraph',
+        content: [
+          {
+            node_type: 'text',
+            value: faker.lorem.sentence(),
+            marks: [],
+            data: {},
+          },
+        ],
+        data: {},
+      },
+    ],
+  };
+};
+
+const getArrayFake = async (field: FieldInfo): Promise<unknown[]> => {
+  const { validations } = field.settings;
+  const { size } = validations.find((validation) => Boolean(validation?.size)) || {};
+  let count = randomInt(0, 10);
+  if (size) {
+    count = randomInt(size?.min ?? 0, size?.max ?? (size?.min ?? 0) + 10);
+  }
+
+  if (field.settings.items.type === FIELD_TYPE_SYMBOL) {
+    return Promise.all(
+      Array(count)
+        .fill('')
+        .map(async () =>
+          getSymbolFake({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+          })
+        )
+    );
+  }
+
+  if (field.settings.items.type === FIELD_TYPE_TEXT) {
+    return Promise.all(
+      Array(count)
+        .fill('')
+        .map(async () =>
+          getTextFake({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+          })
+        )
+    );
+  }
+
+  if (
+    field.settings.items.type === FIELD_TYPE_LINK &&
+    field.settings.items.linkType === LINK_TYPE_ASSET
+  ) {
+    return Promise.all(
+      Array(count)
+        .fill('')
+        .map(async () => getAssetFake())
+    );
+  }
+
+  if (
+    field.settings.items.type === FIELD_TYPE_LINK &&
+    field.settings.items.linkType === LINK_TYPE_ENTRY
+  ) {
+    return Promise.all(
+      Array(count)
+        .fill('')
+        .map(async () =>
+          getEntryScheme({
+            ...field,
+            settings: { ...field.settings.items, id: field.settings.id },
+          })
+        )
+    );
+  }
+};

package/src/lib/helper.ts

@@ -0,0 +1,11 @@
+export const oneOf = <T = string>(array: T[] = []): T => {
+  const index = randomInt(0, array.length);
+
+  return array[index];
+};
+
+export const randomInt = (min = 0, max = 1000000) => {
+  min = Math.ceil(min || 0);
+  max = Math.floor(max || 1000000);
+  return Math.floor(Math.random() * (max - min)) + min;
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "strict": false
+  },
+  "include": ["./src/index.ts","./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}