@contentful/app-scripts 1.33.0-alpha.0 → 2.0.0

package/lib/bin.js

@@ -83,6 +83,16 @@ async function runCommand(command, options) {
         .action(async (options) => {
         await runCommand(index_1.buildFunctions, options);
     });
+    commander_1.program
+        .command('generate-function')
+        .description('Generate a new Contentful Function')
+        .option('--name <name>', 'Name of the function')
+        .option('--template <language>', 'Select a template and language for the function')
+        .option('--example <example_name>', 'Select an example function to generate')
+        .option('--language <language>', 'Select a language for the function')
+        .action(async (options) => {
+        await runCommand(index_1.generateFunction, options);
+    });
     commander_1.program
         .command('upsert-actions')
         .description('Upsert Action(s) for an App')

package/lib/generate-function/build-generate-function-settings.d.ts

@@ -0,0 +1,3 @@
+import { GenerateFunctionSettings, GenerateFunctionOptions } from '../types';
+export declare function buildGenerateFunctionSettings(): Promise<GenerateFunctionSettings>;
+export declare function buildGenerateFunctionSettingsFromOptions(options: GenerateFunctionOptions): Promise<GenerateFunctionSettings>;

package/lib/generate-function/build-generate-function-settings.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGenerateFunctionSettings = buildGenerateFunctionSettings;
+exports.buildGenerateFunctionSettingsFromOptions = buildGenerateFunctionSettingsFromOptions;
+const inquirer_1 = __importDefault(require("inquirer"));
+const path_1 = __importDefault(require("path"));
+const get_github_folder_names_1 = require("./get-github-folder-names");
+const constants_1 = require("./constants");
+const ora_1 = __importDefault(require("ora"));
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
+async function buildGenerateFunctionSettings() {
+    const baseSettings = await inquirer_1.default.prompt([
+        {
+            name: 'name',
+            message: `Function name (${path_1.default.basename(process.cwd())}):`,
+        },
+        {
+            name: 'sourceType',
+            message: 'Do you want to start with a blank template or use one of our examples?',
+            type: 'list',
+            choices: [
+                { name: 'Template', value: 'template' },
+                { name: 'Example', value: 'example' },
+            ],
+            default: 'template',
+        }
+    ]);
+    if (constants_1.BANNED_FUNCTION_NAMES.includes(baseSettings.name)) {
+        throw new Error(`Invalid function name: ${baseSettings.name}`);
+    }
+    let sourceSpecificSettings;
+    if (baseSettings.sourceType === 'template') {
+        sourceSpecificSettings = await inquirer_1.default.prompt([
+            {
+                name: 'language',
+                message: 'Pick a template',
+                type: 'list',
+                choices: [
+                    { name: 'TypeScript', value: 'typescript' },
+                    { name: 'JavaScript', value: 'javascript' },
+                ],
+                default: 'typescript',
+            }
+        ]);
+        sourceSpecificSettings.sourceName = sourceSpecificSettings.language.toLowerCase();
+    }
+    else {
+        const availableExamples = await (0, get_github_folder_names_1.getGithubFolderNames)();
+        const filteredExamples = availableExamples.filter((template) => constants_1.ACCEPTED_EXAMPLE_FOLDERS.includes(template));
+        sourceSpecificSettings = await inquirer_1.default.prompt([
+            {
+                name: 'sourceName',
+                message: 'Select an example:',
+                type: 'list',
+                choices: filteredExamples,
+            },
+            {
+                name: 'language',
+                message: 'Pick a template',
+                type: 'list',
+                choices: [
+                    { name: 'TypeScript', value: 'typescript' },
+                    { name: 'JavaScript', value: 'javascript' },
+                ],
+                default: 'typescript',
+            }
+        ]);
+    }
+    baseSettings.sourceName = sourceSpecificSettings.sourceName;
+    baseSettings.language = sourceSpecificSettings.language;
+    return baseSettings;
+}
+function validateArguments(options) {
+    const templateRequired = ['name', 'template'];
+    const exampleRequired = ['name', 'example', 'language'];
+    if (constants_1.BANNED_FUNCTION_NAMES.includes(options.name)) {
+        throw new Error(`Invalid function name: ${options.name}`);
+    }
+    if ('template' in options) {
+        if (!templateRequired.every((key) => key in options)) {
+            throw new Error('You must specify a function name and a template');
+        }
+    }
+    else if ('example' in options) {
+        if (!exampleRequired.every((key) => key in options)) {
+            throw new Error('You must specify a function name, an example, and a language');
+        }
+    }
+    else {
+        throw new Error('You must specify either --template or --example');
+    }
+}
+async function buildGenerateFunctionSettingsFromOptions(options) {
+    const validateSpinner = (0, ora_1.default)('Validating your input\n').start();
+    const settings = {};
+    try {
+        validateArguments(options);
+        for (const key in options) { // convert all options to lowercase and trim
+            const optionKey = key;
+            options[optionKey] = options[optionKey].toLowerCase().trim();
+        }
+        if ('example' in options) {
+            if ('template' in options) {
+                throw new Error('Cannot specify both --template and --example');
+            }
+            if (!constants_1.ACCEPTED_EXAMPLE_FOLDERS.includes(options.example)) {
+                throw new Error(`Invalid example name: ${options.example}`);
+            }
+            if (!constants_1.ACCEPTED_LANGUAGES.includes(options.language)) {
+                (0, logger_1.warn)(`Invalid language: ${options.language}. Defaulting to TypeScript.`);
+                settings.language = 'typescript';
+            }
+            else {
+                settings.language = options.language;
+            }
+            settings.sourceType = 'example';
+            settings.sourceName = options.example;
+            settings.name = options.name;
+        }
+        else if ('template' in options) {
+            if ('language' in options && options.language && options.language != options.template) {
+                console.warn(`Ignoring language option: ${options.language}. Defaulting to ${options.template}.`);
+            }
+            if (!constants_1.ACCEPTED_LANGUAGES.includes(options.template)) {
+                console.warn(`Invalid language: ${options.template}. Defaulting to TypeScript.`);
+                settings.language = 'typescript';
+                settings.sourceName = 'typescript';
+            }
+            else {
+                settings.language = options.template;
+                settings.sourceName = options.template;
+            }
+            settings.sourceType = 'template';
+            settings.name = options.name;
+        }
+        return settings;
+    }
+    catch (err) {
+        console.log(`
+        ${chalk_1.default.red('Validation failed')}
+        ${err.message}
+      `);
+        // eslint-disable-next-line no-process-exit
+        process.exit(1);
+    }
+    finally {
+        validateSpinner.stop();
+    }
+}

package/lib/generate-function/clone.d.ts

@@ -0,0 +1,14 @@
+import { GenerateFunctionSettings } from '../types';
+export declare function cloneFunction(localPath: string, settings: GenerateFunctionSettings): Promise<void>;
+export declare function getCloneURL(settings: GenerateFunctionSettings): string;
+export declare function touchupAppManifest(localPath: string, settings: GenerateFunctionSettings, renameFunctionFile: string): Promise<void>;
+export declare function moveFilesToFinalDirectory(localTmpPath: string, localFunctionsPath: string): void;
+export declare function renameClonedFiles(localTmpPath: string, settings: GenerateFunctionSettings): string;
+export declare function resolvePaths(localPath: string): {
+    localTmpPath: string;
+    localFunctionsPath: string;
+};
+export declare function cloneAndResolveManifests(cloneURL: string, localTmpPath: string, localPath: string, localFunctionsPath: string): Promise<void>;
+export declare function clone(cloneURL: string, localFunctionsPath: string): Promise<any>;
+export declare function mergeAppManifest(localPath: string, localTmpPath: string): Promise<void>;
+export declare function updatePackageJsonWithBuild(localPath: string, localTmpPath: string): Promise<void>;

package/lib/generate-function/clone.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneFunction = cloneFunction;
+exports.getCloneURL = getCloneURL;
+exports.touchupAppManifest = touchupAppManifest;
+exports.moveFilesToFinalDirectory = moveFilesToFinalDirectory;
+exports.renameClonedFiles = renameClonedFiles;
+exports.resolvePaths = resolvePaths;
+exports.cloneAndResolveManifests = cloneAndResolveManifests;
+exports.clone = clone;
+exports.mergeAppManifest = mergeAppManifest;
+exports.updatePackageJsonWithBuild = updatePackageJsonWithBuild;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const tiged = require('tiged');
+const node_fs_1 = __importDefault(require("node:fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const logger_1 = require("./logger");
+const file_1 = require("./utils/file");
+const package_1 = require("./utils/package");
+const addBuildCommand = (0, package_1.getAddBuildCommandFn)({
+    name: 'build:functions',
+    command: 'contentful-app-scripts build-functions --ci',
+});
+async function cloneFunction(localPath, settings) {
+    try {
+        console.log((0, logger_1.highlight)(`---- Cloning function ${chalk_1.default.cyan(settings.name)}...`));
+        const { localTmpPath, localFunctionsPath } = resolvePaths(localPath);
+        const cloneURL = getCloneURL(settings);
+        await cloneAndResolveManifests(cloneURL, localTmpPath, localPath, localFunctionsPath);
+        // now rename the function file. Find the file with a .ts or .js extension
+        const renameFunctionFile = renameClonedFiles(localTmpPath, settings);
+        // copy the cloned files to the functions directory
+        moveFilesToFinalDirectory(localTmpPath, localFunctionsPath);
+        // now alter the app-manifest.json to point to the new function file
+        await touchupAppManifest(localPath, settings, renameFunctionFile);
+    }
+    catch (e) {
+        (0, logger_1.error)(`Failed to clone function ${(0, logger_1.highlight)(chalk_1.default.cyan(settings.name))}`, e);
+        process.exit(1);
+    }
+}
+function getCloneURL(settings) {
+    let cloneURL = `${constants_1.REPO_URL}/${settings.sourceName}`; // this is the default for template
+    if (settings.sourceType === 'example') {
+        cloneURL = `${constants_1.REPO_URL}/${settings.sourceName}/${settings.language}`;
+    }
+    return cloneURL;
+}
+async function touchupAppManifest(localPath, settings, renameFunctionFile) {
+    const appManifest = JSON.parse(node_fs_1.default.readFileSync(`${localPath}/${constants_1.CONTENTFUL_APP_MANIFEST}`, 'utf-8'));
+    const entry = appManifest["functions"][appManifest["functions"].length - 1];
+    entry.id = settings.name;
+    // the path always has a .js extension
+    entry.path = `./functions/${renameFunctionFile.replace('.ts', '.js')}`;
+    entry.entryFile = `./functions/${renameFunctionFile}`;
+    await node_fs_1.default.writeFileSync(`${localPath}/${constants_1.CONTENTFUL_APP_MANIFEST}`, JSON.stringify(appManifest, null, 2));
+}
+function moveFilesToFinalDirectory(localTmpPath, localFunctionsPath) {
+    node_fs_1.default.cpSync(localTmpPath, localFunctionsPath, { recursive: true });
+    node_fs_1.default.rmSync(localTmpPath, { recursive: true, force: true });
+}
+function renameClonedFiles(localTmpPath, settings) {
+    const files = node_fs_1.default.readdirSync(localTmpPath);
+    const functionFile = files.find((file) => file.endsWith('.ts') || file.endsWith('.js'));
+    if (!functionFile) {
+        throw new Error(`No function file found in ${localTmpPath}`);
+    }
+    const newFunctionFile = `${settings.name}.${settings.language === 'typescript' ? 'ts' : 'js'}`;
+    node_fs_1.default.renameSync(`${localTmpPath}/${functionFile}`, `${localTmpPath}/${newFunctionFile}`);
+    return newFunctionFile;
+}
+function resolvePaths(localPath) {
+    const localTmpPath = (0, path_1.resolve)(`${localPath}/tmp`); // we require a tmp directory because tiged overwrites all files in the target directory
+    const localFunctionsPath = (0, path_1.resolve)(`${localPath}/functions`);
+    return { localTmpPath, localFunctionsPath };
+}
+async function cloneAndResolveManifests(cloneURL, localTmpPath, localPath, localFunctionsPath) {
+    const tigedInstance = await clone(cloneURL, localTmpPath);
+    // merge the manifest from the template folder to the root folder
+    await mergeAppManifest(localPath, localTmpPath);
+    // modify package.json build commands
+    await updatePackageJsonWithBuild(localPath, localTmpPath);
+    // check if a tsconfig.json file exists already
+    const ignoredFiles = constants_1.IGNORED_CLONED_FILES;
+    const tsconfigExists = await (0, file_1.exists)(`${localFunctionsPath}/tsconfig.json`);
+    if (tsconfigExists) {
+        ignoredFiles.push('tsconfig.json');
+    }
+    // remove the cloned files that we've already merged
+    await tigedInstance.remove("unused_param", localTmpPath, {
+        action: 'remove',
+        files: ignoredFiles.map((fileName) => `${localTmpPath}/${fileName}`),
+    });
+}
+async function clone(cloneURL, localFunctionsPath) {
+    const tigedInstance = tiged(cloneURL, { mode: 'tar', disableCache: true, force: true });
+    await tigedInstance.clone(localFunctionsPath);
+    return tigedInstance;
+}
+async function mergeAppManifest(localPath, localTmpPath) {
+    const finalAppManifestType = await (0, file_1.exists)(`${localPath}/${constants_1.CONTENTFUL_APP_MANIFEST}`);
+    const tmpAppManifestType = await (0, file_1.whichExists)(localTmpPath, [constants_1.CONTENTFUL_APP_MANIFEST, constants_1.APP_MANIFEST]); // find the app manifest in the cloned files
+    if (!finalAppManifestType) {
+        await (0, file_1.mergeJsonIntoFile)({
+            source: `${localTmpPath}/${tmpAppManifestType}`,
+            destination: `${localPath}/${constants_1.CONTENTFUL_APP_MANIFEST}`, // always save as contentful-app-manifest.json
+        });
+    }
+    else {
+        // add the function to the json's "functions" array
+        await (0, file_1.mergeJsonIntoFile)({
+            source: `${localTmpPath}/${tmpAppManifestType}`,
+            destination: `${localPath}/${constants_1.CONTENTFUL_APP_MANIFEST}`,
+            mergeFn: (destinationJson = {}, sourceJson = {}) => {
+                if (!destinationJson.functions) {
+                    destinationJson.functions = [];
+                }
+                if (sourceJson.functions && sourceJson.functions.length > 0) {
+                    destinationJson.functions.push(sourceJson.functions[0]);
+                }
+                return destinationJson;
+            },
+        });
+    }
+}
+async function updatePackageJsonWithBuild(localPath, localTmpPath) {
+    const packageJsonLocation = (0, path_1.resolve)(`${localPath}/package.json`);
+    const packageJsonExists = await (0, file_1.exists)(packageJsonLocation);
+    if (packageJsonExists) {
+        await (0, file_1.mergeJsonIntoFile)({
+            source: `${localTmpPath}/package.json`,
+            destination: packageJsonLocation,
+            mergeFn: addBuildCommand,
+        });
+    }
+    else {
+        (0, logger_1.warn)("Failed to add function build commands: ${packageJsonLocation} does not exist.");
+    }
+}

package/lib/generate-function/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const EXAMPLES_PATH = "contentful/apps/function-examples/";
+export declare const APP_MANIFEST = "app-manifest.json";
+export declare const CONTENTFUL_APP_MANIFEST = "contentful-app-manifest.json";
+export declare const IGNORED_CLONED_FILES: string[];
+export declare const REPO_URL = "https://github.com/contentful/apps/function-examples";
+export declare const ACCEPTED_EXAMPLE_FOLDERS: string[];
+export declare const ACCEPTED_LANGUAGES: string[];
+export declare const CONTENTFUL_FUNCTIONS_EXAMPLE_REPO_PATH = "https://api.github.com/repos/contentful/apps/contents/function-examples";
+export declare const BANNED_FUNCTION_NAMES: string[];

package/lib/generate-function/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BANNED_FUNCTION_NAMES = exports.CONTENTFUL_FUNCTIONS_EXAMPLE_REPO_PATH = exports.ACCEPTED_LANGUAGES = exports.ACCEPTED_EXAMPLE_FOLDERS = exports.REPO_URL = exports.IGNORED_CLONED_FILES = exports.CONTENTFUL_APP_MANIFEST = exports.APP_MANIFEST = exports.EXAMPLES_PATH = void 0;
+exports.EXAMPLES_PATH = 'contentful/apps/function-examples/';
+exports.APP_MANIFEST = 'app-manifest.json';
+exports.CONTENTFUL_APP_MANIFEST = 'contentful-app-manifest.json';
+exports.IGNORED_CLONED_FILES = [exports.APP_MANIFEST, `package.json`];
+exports.REPO_URL = 'https://github.com/contentful/apps/function-examples';
+exports.ACCEPTED_EXAMPLE_FOLDERS = [
+    'appevent-handler',
+];
+exports.ACCEPTED_LANGUAGES = ['javascript', 'typescript'];
+exports.CONTENTFUL_FUNCTIONS_EXAMPLE_REPO_PATH = 'https://api.github.com/repos/contentful/apps/contents/function-examples';
+exports.BANNED_FUNCTION_NAMES = ['example', ''];

package/lib/generate-function/create-function.d.ts

@@ -0,0 +1,2 @@
+import { GenerateFunctionSettings } from "../types";
+export declare function create(settings: GenerateFunctionSettings): Promise<void>;

package/lib/generate-function/create-function.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const path_1 = require("path");
+const clone_1 = require("./clone");
+async function create(settings) {
+    const localPath = (0, path_1.resolve)(process.cwd());
+    await (0, clone_1.cloneFunction)(localPath, settings);
+    console.log(`Function "${settings.name}" created successfully`);
+}

package/lib/generate-function/get-github-folder-names.d.ts

@@ -0,0 +1 @@
+export declare function getGithubFolderNames(): Promise<string[]>;

package/lib/generate-function/get-github-folder-names.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGithubFolderNames = getGithubFolderNames;
+const constants_1 = require("./constants");
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("./types");
+async function getGithubFolderNames() {
+    try {
+        const response = await axios_1.default.get(constants_1.CONTENTFUL_FUNCTIONS_EXAMPLE_REPO_PATH);
+        const contents = response.data;
+        const filteredContents = contents.filter((content) => content.type === 'dir');
+        return filteredContents.map((content) => content.name);
+    }
+    catch (err) {
+        if (err instanceof types_1.HTTPResponseError) {
+            throw err;
+        }
+        else {
+            throw new Error(`Failed to fetch Contentful app templates: ${err}`);
+        }
+    }
+}

package/lib/generate-function/index.d.ts

@@ -0,0 +1,5 @@
+import { GenerateFunctionOptions } from "../types";
+export declare const generateFunction: {
+    interactive: () => Promise<void>;
+    nonInteractive: (options: GenerateFunctionOptions) => Promise<void>;
+};

package/lib/generate-function/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFunction = void 0;
+const build_generate_function_settings_1 = require("./build-generate-function-settings");
+const create_function_1 = require("./create-function");
+const interactive = async () => {
+    const generateFunctionSettings = await (0, build_generate_function_settings_1.buildGenerateFunctionSettings)();
+    return (0, create_function_1.create)(generateFunctionSettings);
+};
+const nonInteractive = async (options) => {
+    const generateFunctionSettings = await (0, build_generate_function_settings_1.buildGenerateFunctionSettingsFromOptions)(options);
+    return (0, create_function_1.create)(generateFunctionSettings);
+};
+exports.generateFunction = {
+    interactive,
+    nonInteractive,
+};

package/lib/generate-function/logger.d.ts

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export declare function warn(message: string): void;
+export declare function error(message: string, error: unknown): void;
+export declare function wrapInBlanks(message: string | chalk.Chalk): void;
+export declare function highlight(str: string): string;
+export declare function choice(str: string): string;
+export declare function success(str: string): string;
+export declare function code(str: string): string;

package/lib/generate-function/logger.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+exports.error = error;
+exports.wrapInBlanks = wrapInBlanks;
+exports.highlight = highlight;
+exports.choice = choice;
+exports.success = success;
+exports.code = code;
+const chalk_1 = __importDefault(require("chalk"));
+const types_1 = require("./types");
+function warn(message) {
+    console.log(`${chalk_1.default.yellow('Warning:')} ${message}`);
+}
+function error(message, error) {
+    console.log(`${chalk_1.default.red('Error:')} ${message}`);
+    if (error === undefined) {
+        return;
+    }
+    else if (error instanceof types_1.InvalidTemplateError || error instanceof types_1.HTTPResponseError) {
+        // for known errors, we just want to show the message
+        console.log();
+        console.log(error.message);
+    }
+    else if (error instanceof Error) {
+        console.log();
+        console.log(error);
+    }
+    else {
+        const strigifiedError = String(error);
+        console.log();
+        console.log(`${strigifiedError.startsWith('Error: ') ? strigifiedError.substring(7) : strigifiedError}`);
+    }
+}
+function wrapInBlanks(message) {
+    console.log(' ');
+    console.log(message);
+    console.log(' ');
+}
+function highlight(str) {
+    return chalk_1.default.bold(str);
+}
+function choice(str) {
+    return chalk_1.default.cyan(str);
+}
+function success(str) {
+    return chalk_1.default.greenBright(str);
+}
+function code(str) {
+    return chalk_1.default.bold(str);
+}

package/lib/generate-function/types.d.ts

@@ -0,0 +1,4 @@
+export declare class HTTPResponseError extends Error {
+}
+export declare class InvalidTemplateError extends Error {
+}

package/lib/generate-function/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTemplateError = exports.HTTPResponseError = void 0;
+class HTTPResponseError extends Error {
+}
+exports.HTTPResponseError = HTTPResponseError;
+class InvalidTemplateError extends Error {
+}
+exports.InvalidTemplateError = InvalidTemplateError;

package/lib/generate-function/utils/file.d.ts

@@ -0,0 +1,15 @@
+export declare function getJsonData(path: string | undefined): Promise<Record<string, any> | undefined>;
+export type MergeJsonIntoFileOptions = {
+    destination: string;
+    source?: string;
+    mergeFn?: (destinationJson?: Record<string, any>, sourceJson?: Record<string, any>) => Record<string, any>;
+};
+export declare function mergeJsonIntoFile({ source, destination, mergeFn, }: MergeJsonIntoFileOptions): Promise<void>;
+export declare function exists(path: string): Promise<boolean>;
+/**
+ * Check a directory if two files exist, returning the first one that exists or "None"
+ * @param basePath Base path
+ * @param paths List of paths, in order of preference
+ * @returns First subpath if it exists, otherwise the second if it exists, otherwise "None"
+ */
+export declare function whichExists(basePath: string, paths: string[]): Promise<string>;

package/lib/generate-function/utils/file.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonData = getJsonData;
+exports.mergeJsonIntoFile = mergeJsonIntoFile;
+exports.exists = exists;
+exports.whichExists = whichExists;
+const merge_options_1 = __importDefault(require("merge-options"));
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+async function getJsonData(path) {
+    if (!path) {
+        return undefined;
+    }
+    const normalizedPath = (0, path_1.resolve)(path);
+    if (!(await exists(normalizedPath))) {
+        return undefined;
+    }
+    return JSON.parse(await (0, promises_1.readFile)(normalizedPath, { encoding: 'utf-8' }));
+}
+async function mergeJsonIntoFile({ source, destination, mergeFn = merge_options_1.default.bind({ concatArrays: false }), }) {
+    const sourceJson = await getJsonData(source);
+    const destinationJson = await getJsonData(destination);
+    const mergedJson = mergeFn(destinationJson, sourceJson);
+    await (0, promises_1.writeFile)((0, path_1.resolve)(destination), JSON.stringify(mergedJson, null, '  '));
+}
+function exists(path) {
+    return (0, promises_1.access)(path)
+        .then(() => true)
+        .catch(() => false);
+}
+/**
+ * Check a directory if two files exist, returning the first one that exists or "None"
+ * @param basePath Base path
+ * @param paths List of paths, in order of preference
+ * @returns First subpath if it exists, otherwise the second if it exists, otherwise "None"
+ */
+async function whichExists(basePath, paths) {
+    for (const path of paths) {
+        try {
+            await (0, promises_1.access)((0, path_1.join)(basePath, path));
+            return path;
+        }
+        catch (error) {
+            // Ignore and continue checking the next path
+        }
+    }
+    return "None";
+}

package/lib/generate-function/utils/package.d.ts

@@ -0,0 +1,5 @@
+export type BuildCommandOptions = {
+    name: string;
+    command: string;
+};
+export declare function getAddBuildCommandFn({ name, command }: BuildCommandOptions): (packageJson?: Record<string, any>, additionalProperties?: Record<string, any>) => Record<string, any>;

package/lib/generate-function/utils/package.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAddBuildCommandFn = getAddBuildCommandFn;
+const merge_options_1 = __importDefault(require("merge-options"));
+function getAddBuildCommandFn({ name, command }) {
+    return (packageJson, additionalProperties) => {
+        let destBuildCommand = packageJson?.scripts?.build ?? '';
+        const sourceBuildCommand = additionalProperties?.scripts?.build ?? command;
+        const triggerCommand = `npm run ${name}`;
+        if (destBuildCommand === '') {
+            destBuildCommand = triggerCommand;
+        }
+        else if (!destBuildCommand.split(/\s*&+\s*/).includes(triggerCommand)) {
+            destBuildCommand += ` && ${triggerCommand}`;
+        }
+        return (0, merge_options_1.default)({}, packageJson, additionalProperties, {
+            scripts: { [name]: sourceBuildCommand, build: destBuildCommand },
+        });
+    };
+}

package/lib/index.d.ts

@@ -7,4 +7,5 @@ export { track } from './analytics';
 export { feedback } from './feedback';
 export { install } from './install';
 export { buildFunctions } from './build-functions';
+export { generateFunction } from './generate-function';
 export { upsertActions } from './upsert-actions';

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.upsertActions = exports.buildFunctions = exports.install = exports.feedback = exports.track = exports.open = exports.cleanup = exports.activate = exports.upload = exports.createAppDefinition = void 0;
+exports.upsertActions = exports.generateFunction = exports.buildFunctions = exports.install = exports.feedback = exports.track = exports.open = exports.cleanup = exports.activate = exports.upload = exports.createAppDefinition = void 0;
 var create_app_definition_1 = require("./create-app-definition");
 Object.defineProperty(exports, "createAppDefinition", { enumerable: true, get: function () { return create_app_definition_1.createAppDefinition; } });
 var upload_1 = require("./upload");
@@ -19,5 +19,7 @@ var install_1 = require("./install");
 Object.defineProperty(exports, "install", { enumerable: true, get: function () { return install_1.install; } });
 var build_functions_1 = require("./build-functions");
 Object.defineProperty(exports, "buildFunctions", { enumerable: true, get: function () { return build_functions_1.buildFunctions; } });
+var generate_function_1 = require("./generate-function");
+Object.defineProperty(exports, "generateFunction", { enumerable: true, get: function () { return generate_function_1.generateFunction; } });
 var upsert_actions_1 = require("./upsert-actions");
 Object.defineProperty(exports, "upsertActions", { enumerable: true, get: function () { return upsert_actions_1.upsertActions; } });

package/lib/types.d.ts

@@ -71,3 +71,21 @@ export interface BuildFunctionsOptions {
     esbuildConfig?: string;
     watch?: boolean;
 }
+export type SourceType = 'template' | 'example';
+export type Language = 'javascript' | 'typescript';
+export type AcceptedFunctionExamples = 'appevent-handler';
+export type SourceName = Language | AcceptedFunctionExamples;
+export interface GenerateFunctionSettings {
+    name: string;
+    sourceType: SourceType;
+    sourceName: SourceName;
+    language: Language;
+}
+export type GenerateFunctionOptions = {
+    name: string;
+} & ({
+    example: AcceptedFunctionExamples;
+    language: Language;
+} | {
+    template: Language;
+});

package/lib/upload/create-zip-from-directory.d.ts

@@ -1 +1 @@
-export declare function createZipFileFromDirectory(path: string): Promise<Buffer | null>;
+export declare function createZipFileFromDirectory(path: string): Promise<Buffer<ArrayBufferLike> | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/app-scripts",
-  "version": "1.33.0-alpha.0",
+  "version": "2.0.0",
   "description": "A collection of scripts for building Contentful Apps",
   "author": "Contentful GmbH",
   "license": "MIT",
@@ -10,8 +10,8 @@
     "directory": "packages/contentful--app-scripts"
   },
   "engines": {
-    "node": ">=14",
-    "npm": ">=6"
+    "node": ">=18",
+    "npm": ">=9"
   },
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -51,20 +51,23 @@
     "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
     "@segment/analytics-node": "^2.0.0",
     "adm-zip": "0.5.16",
+    "axios": "^1.7.9",
     "bottleneck": "2.19.5",
     "chalk": "4.1.2",
     "commander": "12.1.0",
-    "contentful-management": "11.47.1",
+    "contentful-management": "11.47.2",
     "dotenv": "16.4.7",
     "esbuild": "^0.25.0",
     "ignore": "7.0.3",
     "inquirer": "8.2.6",
     "lodash": "4.17.21",
+    "merge-options": "^3.0.4",
     "open": "8.4.2",
     "ora": "5.4.1",
+    "tiged": "^2.12.7",
     "zod": "^3.24.1"
   },
-  "gitHead": "dca97555a1140175d238d306f56231d7bcd71b05",
+  "gitHead": "b978a5b14bd327dafbd4349fbc6b624eaffb5e05",
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
     "@types/analytics-node": "3.1.14",
@@ -73,12 +76,12 @@
     "@types/lodash": "4.17.15",
     "@types/mocha": "10.0.10",
     "@types/proxyquire": "1.3.31",
-    "@types/sinon": "17.0.3",
+    "@types/sinon": "17.0.4",
     "chai": "4.5.0",
     "mocha": "10.8.2",
     "proxyquire": "2.1.3",
     "sinon": "19.0.2",
-    "ts-mocha": "10.0.0",
+    "ts-mocha": "11.1.0",
     "ts-node": "10.9.2"
   }
 }