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

package/README.md

@@ -310,43 +310,3 @@ Options:
 -m, --manifest-file <path> Contentful app manifest file path
 -w, --watch watch for changes
 -h, --help display help for command
-
-### Upsert App Actions
-
-Creates or updates Actions for an App using the configuration in a Contentful App Manifest file. Created resources will be synced back to your manifest file.
-
-#### Interactive mode:
-
-In the interactive mode, the CLI will ask for all required options.
-
-> **Example**
->
-> ```shell
-> $ npx --no-install @contentful/app-scripts upsert-actions
-> ```
-
-#### Non-interactive mode:
-
-When passing the `--ci` argument adding all variables as arguments is required.
-
-> **Example**
->
-> ```shell
-> $ npx --no-install @contentful/app-scripts upsert-actions --ci \
->     --manifest-file path/to/contentful-app-manifest.json \
->     --organization-id some-org-id \
->     --definition-id some-app-def-id \
->     --token $MY_CONTENTFUL_PAT
-> ```
-
-**Options:**
-
-| Argument            | Description                                                                                                                                | Default value                  |
-| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------ |
-| `--manifest-file`   | The path to the Contentful app manifest file                                                                                               | `contentful-app-manifest.json` |
-| `--organization-id` | The ID of the organization which the app is defined in                                                                                     |                                |
-| `--definition-id`   | The ID of the app to which to add the actions                                                                                              |                                |
-| `--token`           | A personal [access token](https://www.contentful.com/developers/docs/references/content-management-api/#/reference/personal-access-tokens) |                                |
-| `--host`            | (optional) Contentful CMA-endpoint to use                                                                                                  | `api.contentful.com`           |
-
-**Note:** You can also pass all arguments in interactive mode to skip being asked for it.

package/lib/bin.js

@@ -22,7 +22,7 @@ async function runCommand(command, options) {
         .description('Upload your build folder and create an AppBundle')
         .option('--bundle-dir [directory]', 'The directory of your build folder')
         .option('--organization-id [orgId]', 'The id of your organization')
-        .option('--definition-id [defId]', 'The id of your app\'s definition')
+        .option('--definition-id [defId]', 'The id of your apps definition')
         .option('--token [accessToken]', 'Your content management access token')
         .option('--comment [comment]', 'Optional comment for the created bundle')
         .option('--skip-activation', 'A Boolean flag to skip automatic activation')
@@ -35,7 +35,7 @@ async function runCommand(command, options) {
         .description('Mark an AppBundle as "active" for a given AppDefinition')
         .option('--bundle-id [bundleId]', 'The id of your bundle')
         .option('--organization-id [orgId]', 'The id of your organization')
-        .option('--definition-id  [defId]', 'The id of your app\'s definition')
+        .option('--definition-id  [defId]', 'The id of your apps definition')
         .option('--token [accessToken]', 'Your content management access token')
         .option('--host [host]', 'Contentful subdomain to use, e.g. "api.contentful.com"')
         .action(async (options) => {
@@ -44,7 +44,7 @@ async function runCommand(command, options) {
     commander_1.program
         .command('open-settings')
         .description('Opens the app editor for a given AppDefinition')
-        .option('--definition-id  [defId]', 'The id of your app\'s definition')
+        .option('--definition-id  [defId]', 'The id of your apps definition')
         .option('--host [host]', 'Contentful subdomain to use, e.g. "api.contentful.com"')
         .action(async (options) => {
         await runCommand(index_1.open, options);
@@ -53,7 +53,7 @@ async function runCommand(command, options) {
         .command('bundle-cleanup')
         .description('Removes old, non-active bundles, only keeps the 50 most recent ones')
         .option('--organization-id [orgId]', 'The id of your organization')
-        .option('--definition-id  [defId]', 'The id of your app\'s definition')
+        .option('--definition-id  [defId]', 'The id of your apps definition')
         .option('--token [accessToken]', 'Your content management access token')
         .option('--keep [keepAmount]', 'The amount of bundles that should remain')
         .option('--host [host]', 'Contentful subdomain to use, e.g. "api.contentful.com"')
@@ -69,7 +69,7 @@ async function runCommand(command, options) {
     commander_1.program
         .command('install')
         .description('Opens a picker to select the space and environment for installing the app associated with a given AppDefinition')
-        .option('--definition-id  [defId]', 'The id of your app\'s definition')
+        .option('--definition-id  [defId]', 'The id of your apps definition')
         .option('--host [host]', 'Contentful subdomain to use, e.g. "api.contentful.com"')
         .action(async (options) => {
         await runCommand(index_1.install, options);
@@ -84,15 +84,13 @@ async function runCommand(command, options) {
         await runCommand(index_1.buildFunctions, options);
     });
     commander_1.program
-        .command('upsert-actions')
-        .description('Upsert Action(s) for an App')
-        .option('-m, --manifest-file <path>', 'Contentful app manifest file path')
-        .option('--organization-id [orgId]', 'The id of your organization')
-        .option('--definition-id  [defId]', 'The id of your app\'s definition')
-        .option('--token [accessToken]', 'Your content management access token')
-        .option('--host [host]', 'Contentful subdomain to use, e.g. "api.contentful.com"')
+        .command('generate-function')
+        .description('Generate a new Contentful Function')
+        .option('-n, --name <name>', 'Name of the function')
+        .option('-e, --example <example>', 'Name of the reference example')
+        .option('-l, --language <language>', 'Select a language for the function')
         .action(async (options) => {
-        await runCommand(index_1.upsertActions, options);
+        await runCommand(index_1.generateFunction, options);
     });
     commander_1.program.hook('preAction', (thisCommand) => {
         (0, index_1.track)({ command: thisCommand.args[0], ci: thisCommand.opts().ci });

package/lib/build-functions/build-functions.d.ts

@@ -3,6 +3,7 @@ type ContentfulFunctionToBuild = Omit<ContentfulFunction, 'entryFile'> & {
     entryFile: string;
 };
 export declare const validateFunctions: (manifest: Record<string, any>) => void;
+export declare const resolveManifestFile: (options: BuildFunctionsOptions, cwd?: string) => any;
 export declare const resolveEsBuildConfig: (options: BuildFunctionsOptions, manifest: {
     functions: ContentfulFunctionToBuild[];
 }, cwd?: string) => any;

package/lib/build-functions/build-functions.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEsBuildConfig = exports.validateFunctions = void 0;
+exports.resolveEsBuildConfig = exports.resolveManifestFile = exports.validateFunctions = void 0;
 exports.buildFunctions = buildFunctions;
 /* eslint-disable @typescript-eslint/no-var-requires */
 const esbuild_1 = __importDefault(require("esbuild"));
@@ -11,18 +11,17 @@ const path_1 = require("path");
 const node_modules_polyfill_1 = require("@esbuild-plugins/node-modules-polyfill");
 const node_globals_polyfill_1 = require("@esbuild-plugins/node-globals-polyfill");
 const zod_1 = require("zod");
-const utils_1 = require("../utils");
 const functionManifestSchema = zod_1.z
     .object({
     functions: zod_1.z.array(zod_1.z
         .object({
-        id: zod_1.z.string().regex(utils_1.ID_REGEX, 'Invalid "id" (must only contain alphanumeric characters)'),
+        id: zod_1.z.string(),
         name: zod_1.z.string(),
         description: zod_1.z.string(),
         path: zod_1.z.string(),
         entryFile: zod_1.z.string(),
         accepts: zod_1.z.array(zod_1.z.string()),
-    }, {})
+    })
         .required()),
 })
     .required();
@@ -53,6 +52,12 @@ const validateFunctions = (manifest) => {
     });
 };
 exports.validateFunctions = validateFunctions;
+const resolveManifestFile = (options, cwd = process.cwd()) => {
+    return require(options.manifestFile
+        ? (0, path_1.resolve)(cwd, options.manifestFile)
+        : (0, path_1.resolve)(cwd, 'contentful-app-manifest.json'));
+};
+exports.resolveManifestFile = resolveManifestFile;
 const getEntryPoints = (manifest, cwd = process.cwd()) => {
     return manifest.functions.reduce((result, contentfulFunction) => {
         const fileProperties = (0, path_1.parse)(contentfulFunction.path);
@@ -80,7 +85,7 @@ const resolveEsBuildConfig = (options, manifest, cwd = process.cwd()) => {
 };
 exports.resolveEsBuildConfig = resolveEsBuildConfig;
 async function buildFunctions(options) {
-    const manifest = (0, utils_1.resolveManifestFile)(options);
+    const manifest = (0, exports.resolveManifestFile)(options);
     try {
         console.log('Building functions');
         (0, exports.validateFunctions)(manifest);

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

@@ -0,0 +1,4 @@
+import { GenerateFunctionSettings } from '../types';
+export declare function buildGenerateFunctionSettingsInteractive(): Promise<GenerateFunctionSettings>;
+export declare function validateArguments(options: GenerateFunctionSettings): void;
+export declare function buildGenerateFunctionSettingsCLI(options: GenerateFunctionSettings): Promise<GenerateFunctionSettings>;

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGenerateFunctionSettingsInteractive = buildGenerateFunctionSettingsInteractive;
+exports.validateArguments = validateArguments;
+exports.buildGenerateFunctionSettingsCLI = buildGenerateFunctionSettingsCLI;
+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");
+const types_1 = require("./types");
+async function buildGenerateFunctionSettingsInteractive() {
+    const baseSettings = await inquirer_1.default.prompt([
+        {
+            name: 'name',
+            message: `Function name (${path_1.default.basename(process.cwd())}):`,
+        },
+    ]);
+    validateFunctionName(baseSettings);
+    const filteredSources = await (0, get_github_folder_names_1.getGithubFolderNames)();
+    const sourceSpecificSettings = await inquirer_1.default.prompt([
+        {
+            name: 'example',
+            message: 'Select an example:',
+            type: 'list',
+            choices: filteredSources,
+        },
+        {
+            name: 'language',
+            message: 'Select a language',
+            type: 'list',
+            choices: [
+                { name: 'TypeScript', value: 'typescript' },
+                { name: 'JavaScript', value: 'javascript' },
+            ],
+            default: 'typescript',
+        }
+    ]);
+    baseSettings.example = sourceSpecificSettings.example;
+    baseSettings.language = sourceSpecificSettings.language;
+    return baseSettings;
+}
+function validateFunctionName(baseSettings) {
+    if (constants_1.BANNED_FUNCTION_NAMES.includes(baseSettings.name)) {
+        throw new types_1.ValidationError(chalk_1.default.red(`Invalid function name: ${baseSettings.name} is not allowed.`));
+    }
+    else if (!(/^[a-z0-9]+$/i.test(baseSettings.name))) {
+        throw new types_1.ValidationError(chalk_1.default.red(`Invalid function name: ${baseSettings.name}. Note that function names must be alphanumeric.`));
+    }
+}
+function validateArguments(options) {
+    const requiredParams = ['name', 'example', 'language'];
+    if (!requiredParams.every((key) => key in options)) {
+        throw new types_1.ValidationError(chalk_1.default.red('You must specify a function name, an example, and a language'));
+    }
+    validateFunctionName(options);
+    // Check if the language is valid
+    if (!constants_1.ACCEPTED_LANGUAGES.includes(options.language)) {
+        (0, logger_1.warn)(`Invalid language: ${options.language}. Defaulting to TypeScript.`);
+        options.language = 'typescript';
+    }
+    // Convert options to lowercase and trim whitespace
+    for (const key in options) {
+        const optionKey = key;
+        const value = options[optionKey].toLowerCase().trim();
+        if (optionKey === 'language') {
+            options[optionKey] = value;
+        }
+        else if (optionKey === 'example') {
+            options[optionKey] = value;
+        }
+        else { // don't want to lowercase function names
+            options[optionKey] = options[optionKey].trim();
+        }
+    }
+}
+async function buildGenerateFunctionSettingsCLI(options) {
+    const validateSpinner = (0, ora_1.default)('Validating your input\n').start();
+    const settings = {};
+    try {
+        validateArguments(options);
+        // Check if the source exists
+        const filteredSources = await (0, get_github_folder_names_1.getGithubFolderNames)();
+        if (!filteredSources.includes(options.example)) {
+            throw new types_1.ValidationError(`Invalid example name: ${options.example}. Please choose from: ${filteredSources.join(', ')}`);
+        }
+        settings.language = options.language;
+        settings.example = options.example;
+        settings.name = options.name;
+        return settings;
+    }
+    catch (err) {
+        console.log(`
+        ${chalk_1.default.red('Validation failed')}
+      `);
+        // eslint-disable-next-line no-process-exit
+        throw err;
+    }
+    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,140 @@
+"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);
+        throw Error(chalk_1.default.red('Failed to clone function ') + (0, logger_1.highlight)(chalk_1.default.cyan(settings.name)));
+    }
+}
+function getCloneURL(settings) {
+    return `${constants_1.REPO_URL}/${settings.example}/${settings.language}`;
+}
+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, exports.CONTENTFUL_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 { GenerateFunctionSettings } from "../types";
+export declare const generateFunction: {
+    interactive: () => Promise<void>;
+    nonInteractive: (options: GenerateFunctionSettings) => Promise<void>;
+};

package/lib/generate-function/index.js

@@ -0,0 +1,38 @@
+"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 types_1 = require("./types");
+const interactive = async () => {
+    try {
+        const generateFunctionSettings = await (0, build_generate_function_settings_1.buildGenerateFunctionSettingsInteractive)();
+        return (0, create_function_1.create)(generateFunctionSettings);
+    }
+    catch (e) {
+        if (e instanceof types_1.ValidationError) {
+            console.error(e.message);
+        }
+        else {
+            console.error(e);
+        }
+    }
+};
+const nonInteractive = async (options) => {
+    try {
+        const generateFunctionSettings = await (0, build_generate_function_settings_1.buildGenerateFunctionSettingsCLI)(options);
+        return (0, create_function_1.create)(generateFunctionSettings);
+    }
+    catch (e) {
+        if (e instanceof types_1.ValidationError) {
+            console.error(e.message);
+        }
+        else {
+            console.error(e);
+        }
+    }
+};
+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,7 @@
+export declare class HTTPResponseError extends Error {
+}
+export declare class InvalidTemplateError extends Error {
+}
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}

package/lib/generate-function/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.InvalidTemplateError = exports.HTTPResponseError = void 0;
+class HTTPResponseError extends Error {
+}
+exports.HTTPResponseError = HTTPResponseError;
+class InvalidTemplateError extends Error {
+}
+exports.InvalidTemplateError = InvalidTemplateError;
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;