@adobe/aio-cli-plugin-api-mesh 5.2.4-alpha.0 → 5.2.4-alpha.1

package/src/meshArtifact.js

@@ -0,0 +1,231 @@
+const path = require('path');
+const fs = require('fs');
+const { fixPlugins } = require('./fixPlugins');
+const logger = require('../src/classes/logger');
+
+/**
+ * Whether file is TypeScript
+ * @param filePath Filepath
+ */
+function isTypeScriptFile(filePath) {
+	const ext = path.extname(filePath);
+	return ext === '.ts' || ext === '.tsx';
+}
+
+/**
+ * Gets
+ * @param builtMeshTenantDir
+ * @returns {string}
+ */
+function getBuiltMeshEntrypoint(builtMeshTenantDir) {
+	let builtMeshIndexPath = path.join(builtMeshTenantDir, 'index');
+	return fs.existsSync(`${builtMeshIndexPath}.ts`)
+		? `${builtMeshIndexPath}.ts`
+		: `${builtMeshIndexPath}.js`;
+}
+
+/**
+ * Converts composer string to static imports compatible with bundling
+ * @param data {string} Data read from the built mesh
+ * @returns {string} Updated data
+ * @example Converts composer string
+ * ```
+ * "beforeAll": {
+ *     "composer": "/Users/user/project/hooks.js#isAuth",
+ *     "blocking": true
+ * }
+ * ```
+ * To:
+ * ```
+ * "beforeAll": {
+ *     "module": await import("/Users/user/project/hooks.js"), "fn": "isAuth",
+ *         "blocking": true
+ * }
+ * ```
+ */
+function resolveComposerAsTypeScriptModule(data) {
+	return data.replace(
+		/"composer":\s*"([^#]+)#([^"]+)"/,
+		`"module": await import("$1"), "fn": "$2"`,
+	);
+}
+
+/**
+ * Converts composer string to static imports compatible with bundling
+ * @param data {string} Data read from the built mesh
+ * @returns {string} Updated data
+ * @example Converts composer string
+ * ```
+ * "beforeAll": {
+ *     "composer": "/Users/user/project/hooks.js#isAuth",
+ *     "blocking": true
+ * }
+ * ```
+ * To:
+ * ```
+ * "beforeAll": {
+ *     "module": __importStar(require("/Users/user/project/hooks.js")), "fn": "isAuth",
+ *         "blocking": true
+ * }
+ * ```
+ */
+function resolveComposerAsJavaScriptModule(data) {
+	return data.replace(
+		/"composer":\s*"([^#]+)#([^"]+)"/,
+		`"module": __importStar(require("$1")), "fn": "$2"`,
+	);
+}
+
+/**
+ * Takes a mesh artifact and converts composer configuration to static imports
+ * compatible with bundling
+ * @param meshArtifactPath Path to the mesh artifact used to determine extension
+ * @param data {string} Data read from the built mesh
+ * @returns {string} Updated data
+ * @see {@link resolveComposerAsJavaScriptModule}
+ * @see {@link resolveComposerAsTypeScriptModule}
+ */
+function resolveComposerAsStaticImport(meshArtifactPath, data) {
+	return isTypeScriptFile(meshArtifactPath)
+		? resolveComposerAsTypeScriptModule(data)
+		: resolveComposerAsJavaScriptModule(data);
+}
+
+// /**
+//  * Converts handler string to static imports compatible with bundling
+//  * @param data {string} Data read from the built mesh
+//  * @returns {string} Updated data
+//  * @example Converts composer string
+//  * ```
+//  * "onFetch": {
+//  *     "handler": "/Users/user/project/fetch.js",
+//  *     "blocking": true
+//  * }
+//  * ```
+//  * To:
+//  * ```
+//  * "onFetch": {
+//  *     "handler": await import("/Users/user/project/fetch.js"),
+//  *         "blocking": true
+//  * }
+//  * ```
+//  */
+// function resolveHandlerAsTypeScriptModule(data) {
+// 	return data.replace(/"handler":\s*"([^"]+)"/, `"handler": await import("$1")`);
+// }
+
+// /**
+//  * Converts handler string to static imports compatible with bundling
+//  * @param data {string} Data read from the built mesh
+//  * @returns {string} Updated data
+//  * @example Converts composer string
+//  * ```
+//  * "onFetch": {
+//  *     "handler": "/Users/user/project/fetch.js",
+//  *     "blocking": true
+//  * }
+//  * ```
+//  * To:
+//  * ```
+//  * "onFetch": {
+//  *     "module": __importStar(require("/Users/user/project/fetch.js")),
+//  *         "blocking": true
+//  * }
+//  * ```
+//  */
+// function resolveHandlerAsJavaScriptModule(data) {
+// 	return data.replace(/"handler":\s*"([^"]+)"/, `"handler": __importStar(require("$1"))`);
+// }
+
+// /**
+//  * Takes a mesh artifact and converts handler configuration to static imports
+//  * compatible with bundling
+//  * @param meshArtifactPath Path to the mesh artifact used to determine extension
+//  * @param data {string} Data read from the built mesh
+//  * @returns {string} Updated data
+//  * @see {@link resolveHandlerAsJavaScriptModule}
+//  * @see {@link resolveHandlerAsTypeScriptModule}
+//  */
+// TODO: onFetch support - requires plugin changes
+// function resolveHandlerAsStaticImport(meshArtifactPath, data) {
+// 	return isTypeScriptFile(meshArtifactPath)
+// 		? resolveHandlerAsTypeScriptModule(data)
+// 		: resolveHandlerAsJavaScriptModule(data);
+// }
+
+const resolveRelativeSources = async builtMeshTenantDir => {
+	let builtMeshPath = getBuiltMeshEntrypoint(builtMeshTenantDir);
+
+	// Fix http details extensions plugin for edge compatibility
+	await fixPlugins(builtMeshPath);
+
+	// Read tenant files inventory
+	const artifactFilesPath = path.join(builtMeshTenantDir, 'files.json');
+	if (fs.existsSync(artifactFilesPath)) {
+		// Read mesh artifact
+		let builtMeshData = fs.readFileSync(builtMeshPath).toString();
+
+		const parentDirRegex = new RegExp('../tenantFiles'.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+		builtMeshData = builtMeshData.replace(parentDirRegex, './tenantFiles');
+
+		// Write the modified mesh artifact
+		fs.writeFileSync(builtMeshPath, builtMeshData, 'utf8');
+	}
+};
+
+/**
+ * Resolve original sources to materialized files in mesh artifact for local development and debugging
+ * @param builtMeshTenantDir Built mesh tenant directory
+ * @param localFileOverrides Local file overrides
+ */
+const resolveOriginalSources = async (builtMeshTenantDir, localFileOverrides) => {
+	let builtMeshPath = getBuiltMeshEntrypoint(builtMeshTenantDir);
+
+	// Read tenant files inventory
+	const artifactFilesPath = path.join(builtMeshTenantDir, 'files.json');
+	if (fs.existsSync(artifactFilesPath)) {
+		let files = {};
+		try {
+			files = JSON.parse(fs.readFileSync(artifactFilesPath).toString());
+		} catch (err) {
+			logger.error('Malformed "files.json" file. Skipping original source resolution.');
+		}
+
+		// Read mesh artifact
+		let builtMeshData = fs.readFileSync(builtMeshPath).toString();
+		files.files.forEach(file => {
+			// Skip replacement of files for local development when the user was prompted
+			// to override and answered no
+			if (
+				Object.keys(localFileOverrides).includes(file.path) &&
+				localFileOverrides[file.path] === false
+			) {
+				return;
+			}
+
+			// When the source exists in project use it instead of the materialized file
+			const absoluteFilePath = path.resolve(file.path);
+
+			// Replace all occurrences of the materialized path with the fully qualified original path when it exists
+			if (fs.existsSync(absoluteFilePath)) {
+				const regex = new RegExp(file.materializedPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+				builtMeshData = builtMeshData.replace(regex, absoluteFilePath);
+				builtMeshData = resolveComposerAsStaticImport(builtMeshPath, builtMeshData);
+				// TODO: onFetch support - requires plugin changes
+				// builtMeshData = resolveHandlerAsStaticImport(builtMeshPath, builtMeshData);
+			}
+		});
+
+		// Write the modified mesh artifact
+		fs.writeFileSync(builtMeshPath, builtMeshData, 'utf8');
+	}
+};
+
+module.exports = {
+	isTypeScriptFile,
+	resolveComposerAsTypeScriptModule,
+	resolveComposerAsJavaScriptModule,
+	resolveComposerAsStaticImport,
+	resolveRelativeSources,
+	resolveOriginalSources,
+};

package/src/project.js

@@ -0,0 +1,56 @@
+const { cpSync, existsSync, renameSync, rmSync } = require('node:fs');
+const { join } = require('node:path');
+const { resolveOriginalSources } = require('./meshArtifact');
+
+const BUILT_MESH_ARTIFACT_DIRECTORY = 'mesh-artifact';
+const BUILT_MESH_TENANT_FILES_DIRECTORY = join(BUILT_MESH_ARTIFACT_DIRECTORY, 'tenantFiles');
+const PACKAGED_MESH_DIR = '.mesh';
+const PACKAGED_MESH_DIR_TENANT_FILES_DIRECTORY = join(PACKAGED_MESH_DIR, 'tenantFiles');
+const PACKAGED_MESH_CLI_MIRROR_DIR = `${__dirname}/../${PACKAGED_MESH_DIR}`;
+const TEMP_FILES_DIRECTORY = 'tempfiles';
+const getBuiltMeshTenantDirectory = meshId => join(BUILT_MESH_ARTIFACT_DIRECTORY, meshId);
+
+/**
+ * Copy built mesh artifact to packaged directory that runs local development.
+ * @param builtMeshTenantDir Built mesh directory path
+ * @returns {Promise<void>}
+ */
+const copyBuiltMeshToPackage = async builtMeshTenantDir => {
+	// Reset packaged directories
+	safeDelete(PACKAGED_MESH_DIR);
+	safeDelete(PACKAGED_MESH_CLI_MIRROR_DIR);
+
+	// Copy the built mesh to the packaged directory for in-project SDK
+	safeRename(builtMeshTenantDir, PACKAGED_MESH_DIR);
+	safeRename(BUILT_MESH_TENANT_FILES_DIRECTORY, PACKAGED_MESH_DIR_TENANT_FILES_DIRECTORY);
+
+	// Copy the packaged mesh to the CLI mirror directory for local server
+	safeCopy(PACKAGED_MESH_DIR, PACKAGED_MESH_CLI_MIRROR_DIR);
+};
+
+const safeDelete = path => {
+	if (existsSync(path)) {
+		rmSync(path, { recursive: true });
+	}
+};
+
+const safeRename = (oldPath, newPath) => {
+	if (existsSync(oldPath)) {
+		renameSync(oldPath, newPath);
+	}
+};
+
+const safeCopy = (source, destination) => {
+	if (existsSync(source)) {
+		cpSync(source, destination, { recursive: true });
+	}
+};
+
+module.exports = {
+	BUILT_MESH_ARTIFACT_DIRECTORY,
+	safeDelete,
+	copyBuiltMeshToPackage,
+	resolveOriginalSources,
+	TEMP_FILES_DIRECTORY,
+	getBuiltMeshTenantDirectory,
+};

package/src/server.js

@@ -1,38 +1,80 @@
-const { spawn } = require('child_process');
-const { readSecretsFile } = require('./serverUtils');
-const packageData = require('../package.json');
-
-const runServer = portNo => {
-	const wranglerPackageNumber = packageData.dependencies.wrangler;
-	const wranglerVersion = `wrangler@${wranglerPackageNumber.replace(/^[\^~]/, '')}`;
-	const indexFilePath = `${__dirname}/index.js`;
-	const filePath = '.mesh';
-	const secrets = readSecretsFile(filePath);
-	const commandArgs = [
-		wranglerVersion,
-		'dev',
-		indexFilePath,
-		'--show-interactive-dev-session',
-		'false',
-		'--var',
-		`Secret:${JSON.stringify(secrets)}`,
-		'--port',
-		portNo,
-		'--inspector-port',
-		'9229',
-	];
-
-	const wrangler = spawn('npx', commandArgs, {
-		stdio: 'inherit',
-	});
+import { getMesh } from '@graphql-mesh/runtime';
+
+const { getCorsOptions } = require('./cors');
+const { createYoga } = require('graphql-yoga');
+const { GraphQLError } = require('graphql/error');
+
+const { loadMeshSecrets, getSecretsHandler } = require('./secrets');
+const useComplianceHeaders = require('./plugins/complianceHeaders');
+const UseHttpDetailsExtensions = require('./plugins/httpDetailsExtensions');
+const useSourceHeaders = require('@adobe/plugin-source-headers');
+const { useDisableIntrospection } = require('@envelop/disable-introspection');
+
+let meshInstance$;
+
+async function buildMeshInstance(meshArtifacts, meshConfig) {
+	const { getMeshOptions } = meshArtifacts;
+	const options = await getMeshOptions();
+
+	options.additionalEnvelopPlugins = (options.additionalEnvelopPlugins || []).concat(
+		useComplianceHeaders(),
+		UseHttpDetailsExtensions({
+			// Get the details of responseConfig.includeHTTPDetails and store in Cache
+			if: meshConfig.responseConfig?.includeHTTPDetails || false,
+		}),
+		useSourceHeaders(meshConfig),
+	);
 
-	wrangler.on('close', code => {
-		console.log(`wrangler dev process exited with code ${code}`);
+	if (meshConfig.disableIntrospection) {
+		options.additionalEnvelopPlugins.push(useDisableIntrospection());
+	}
+
+	return getMesh(options).then(mesh => {
+		const id = mesh.pubsub.subscribe('destroy', () => {
+			meshInstance$ = undefined;
+			mesh.pubsub.unsubscribe(id);
+		});
+		return mesh;
 	});
+}
+
+async function getBuiltMesh(meshArtifacts, meshConfig) {
+	if (meshInstance$ == null) {
+		meshInstance$ = buildMeshInstance(meshArtifacts, meshConfig);
+	}
+	return meshInstance$;
+}
+
+const buildServer = async (loggerInstance, env, meshArtifacts, meshConfig) => {
+	const { Secret: secret } = env;
+	const tenantMesh = await getBuiltMesh(meshArtifacts, meshConfig);
+	const meshSecrets = loadMeshSecrets(loggerInstance, secret);
+	return await buildYogaServer(env, tenantMesh, meshConfig, meshSecrets);
+};
 
-	wrangler.on('error', error => {
-		console.error(`Failed to start wrangler dev: ${error.message}`);
+async function buildYogaServer(env, tenantMesh, meshConfig, meshSecrets) {
+	const secretsProxy = new Proxy(meshSecrets, getSecretsHandler);
+	return createYoga({
+		plugins: tenantMesh.plugins,
+		graphqlEndpoint: `/graphql`,
+		cors: getCorsOptions(env, meshConfig),
+		context: initialContext => ({
+			...initialContext,
+			secrets: secretsProxy,
+		}),
+		maskedErrors: {
+			maskError: maskError,
+		},
+		logging: 'debug',
 	});
+}
+
+const maskError = error => {
+	if (error instanceof GraphQLError && error.extensions?.http?.headers) {
+		delete error.extensions.http.headers;
+	}
+
+	return error;
 };
 
-module.exports = { runServer };
+module.exports = { buildServer };

package/src/utils.js

@@ -6,7 +6,6 @@ const { readFile } = require('fs/promises');
 const { interpolateMesh } = require('./helpers');
 const dotenv = require('dotenv');
 const YAML = require('yaml');
-const ms = require('ms');
 const parseEnv = require('envsub/js/envsub-parser');
 const os = require('os');
 const chalk = require('chalk');
@@ -62,6 +61,13 @@ const secretsFlag = Flags.string({
 const portNoFlag = Flags.integer({
 	char: 'p',
 	description: 'Port number for the local dev server',
+	default: 5000,
+});
+
+const inspectPortNoFlag = Flags.integer({
+	char: 'i',
+	description: 'Port number for the local dev server inspector',
+	default: 9229,
 });
 
 const debugFlag = Flags.boolean({
@@ -87,11 +93,7 @@ const endTimeFlag = Flags.string({
 });
 
 const pastFlag = Flags.string({
-	description: 'Past time window in mins',
-});
-
-const fromFlag = Flags.string({
-	description: `The from time in YYYY-MM-DD:HH:MM:SS format based on your system's time zone. It is used to fetch logs from the past and is the starting time for the past time duration.`,
+	description: 'Past time window in minutes',
 });
 
 const logFilenameFlag = Flags.string({
@@ -320,7 +322,7 @@ function checkPlaceholders(mesh) {
  * @param {string} file
  * @param {object} command
  * @param {string} filetype
- * @returns {string}
+ * @returns {Promise<string>}
  */
 async function readFileContents(file, command, filetype) {
 	try {
@@ -388,7 +390,7 @@ function validateFileName(filesList) {
  * @param {string} inputMeshData
  * @param {string} envFilePath
  * @param {object} command
- * @returns {string}
+ * @returns {Promise<string>}
  */
 async function validateAndInterpolateMesh(inputMeshData, envFilePath, command) {
 	//Read the environment file
@@ -658,23 +660,21 @@ function suggestCorrectedDateFormat(inputDate) {
 /**
  * Parses a duration string representing a past time window and converts it to milliseconds.
  *
- * @param {string} pastTimeWindow - The past time duration to parse, e.g., "20 mins", "15 minutes".
+ * @param {string} pastTimeWindow - The past time duration in minutes, e.g., "20", "15".
  * @returns {number} The duration in milliseconds.
  */
 function parsePastDuration(pastTimeWindow) {
-	// Regular expression to match various formats of minute abbreviations
-	const pastDurationRegex = /^(\d+)\s*(m|mins?|minutes?)$/i;
-	const match = pastTimeWindow.match(pastDurationRegex);
+	// Check if pastTimeWindow contains non-numeric characters
+	const match = pastTimeWindow.match(/^(\d+)$/);
+
+	const durationInMs = Number(pastTimeWindow) * 60 * 1000;
 
-	if (!match) {
+	if (isNaN(durationInMs) || !match) {
 		throw new Error(
-			'Invalid format. The past time window should be in minutes, for example, "20 mins", "15 minutes".',
+			'Invalid format. The time window must be an integer, for example "20" or "15".',
 		);
 	}
 
-	// Convert the matched duration to milliseconds
-	const durationInMs = ms(pastTimeWindow);
-
 	return durationInMs;
 }
 
@@ -714,14 +714,15 @@ function validateDateTimeRange(startTime, endTime) {
 		throw new Error('endTime cannot be in the future. Provide a valid endTime.');
 	}
 
-	if (start.getTime() === end.getTime()) {
-		throw new Error('The minimum duration is 1 minutes. The current duration is 0 minutes.');
-	}
-
-	// Check if the duration between start and end times is greater than 30 minutes (1800 seconds)
 	const timeDifferenceInSeconds = (end.getTime() - start.getTime()) / 1000;
 
-	if (timeDifferenceInSeconds > 1800) {
+	if (timeDifferenceInSeconds < 60) {
+		// Check if the duration between start and end times is less than 1 minute (60 seconds)
+		throw new Error(
+			`The minimum duration is 1 minute. The current duration is ${timeDifferenceInSeconds} seconds.`,
+		);
+	} else if (timeDifferenceInSeconds > 1800) {
+		// Check if the duration between start and end times is greater than 30 minutes (1800 seconds)
 		const hours = Math.floor(timeDifferenceInSeconds / 3600); // Hours calculation
 		const minutes = Math.floor((timeDifferenceInSeconds % 3600) / 60); // Minutes calculation
 		const seconds = timeDifferenceInSeconds % 60; // Seconds calculation
@@ -762,6 +763,7 @@ function validateDateTimeFormat(time) {
 	return timeString.replace(/-|:|Z/g, '').replace('T', 'T');
 }
 
+// can be used later if we want to take --startTime and --endTime in local time
 /**
  * Convert a given local time string to UTC time string
  * @param {string} timeString - The time string in the format YYYY-MM-DD:HH:MM:SS
@@ -803,6 +805,7 @@ module.exports = {
 	validateAndInterpolateMesh,
 	getAppRootDir,
 	portNoFlag,
+	inspectPortNoFlag,
 	debugFlag,
 	selectFlag,
 	secretsFlag,
@@ -814,7 +817,6 @@ module.exports = {
 	endTimeFlag,
 	logFilenameFlag,
 	pastFlag,
-	fromFlag,
 	suggestCorrectedDateFormat,
 	parsePastDuration,
 	validateDateTimeRange,

package/src/{index.js → worker.js}

@@ -1,7 +1,7 @@
 import { ServedTier, addServedHeader } from './served';
+import { buildServer } from './server';
 import { bindedlogger as logger } from './utils/logger';
 import { getRequestId } from './utils/requestId';
-import { buildServer } from './wranglerServer';
 
 let server;
 
@@ -21,10 +21,10 @@ export default {
 		const { MESH_ID: meshId, LOG_LEVEL: logLevel } = env;
 		const loggerInstance = logger({ logLevel, meshId, requestId });
 		const meshArtifacts = await import('../.mesh');
-		const rawMesh = await import('../.mesh/.meshrc.json');
+		const meshConfig = await import('../.mesh/.meshrc.json');
 
 		if (!server) {
-			server = await this.buildAndCacheServer(env, loggerInstance, meshArtifacts, rawMesh);
+			server = await this.buildAndCacheServer(env, loggerInstance, meshArtifacts, meshConfig);
 		}
 
 		loggerInstance.debug('WORKER HOT: Fetching via worker');
@@ -34,11 +34,13 @@ export default {
 	},
 	/**
 	 * Build and cache mesh instance/server in global variable.
-	 * @param env
-	 * @param loggerInstance
+	 * @param env Environment
+	 * @param logger Logger
+	 * @param meshArtifacts Mesh artifact
+	 * @param meshConfig Mesh config
 	 */
-	async buildAndCacheServer(env, loggerInstance, meshArtifacts, meshConfig) {
-		server = await buildServer(loggerInstance, env, meshArtifacts, meshConfig);
+	async buildAndCacheServer(env, logger, meshArtifacts, meshConfig) {
+		server = await buildServer(logger, env, meshArtifacts, meshConfig);
 		return server;
 	},
 };

package/src/wranglerCli.js

@@ -0,0 +1,54 @@
+const { spawn } = require('child_process');
+const { readSecretsFile } = require('./serverUtils');
+const packageData = require('../package.json');
+const { join } = require('node:path');
+
+/**
+ * Starts the wrangler dev server
+ * @param command {Command} CLI command
+ * @param port Port number
+ * @param debug Whether debug mode is enabled
+ * @param inspectPort Port number for local dev server inspector
+ */
+const start = (command, port, debug, inspectPort) => {
+	const wranglerPackageNumber = packageData.dependencies.wrangler;
+	const wranglerVersion = `wrangler@${wranglerPackageNumber.replace(/^[\^~]/, '')}`;
+	const wranglerToml = join(__dirname, '..', 'wrangler.toml');
+	const meshDir = '.mesh';
+	const secrets = readSecretsFile(meshDir);
+	const entrypoint = join(__dirname, 'worker.js');
+
+	const commandArgs = [
+		wranglerVersion,
+		'--config',
+		wranglerToml,
+		'--cwd',
+		process.cwd(),
+		'dev',
+		entrypoint,
+		'--show-interactive-dev-session',
+		'false',
+		'--var',
+		`Secret:${JSON.stringify(secrets)}`,
+		'--port',
+		port,
+		'--inspector-port',
+		debug ? inspectPort : 0,
+	];
+
+	const wrangler = spawn('npx', commandArgs, {
+		stdio: 'inherit',
+	});
+
+	wrangler.on('close', code => {
+		// eslint-disable-next-line no-console
+		console.log(`wrangler dev process exited with code ${code}`);
+	});
+
+	wrangler.on('error', error => {
+		// eslint-disable-next-line no-console
+		console.error(`Failed to start wrangler dev: ${error.message}`);
+	});
+};
+
+module.exports = { start };

package/wrangler.toml

@@ -0,0 +1,13 @@
+# Tenant worker core definition. For platform workers metadata configs are used to set bindings.
+name = "tenant-worker-core"
+compatibility_date = "2024-06-03"
+
+find_additional_modules = true
+base_dir = ".mesh"
+rules = [
+  { type = "CommonJS", globs = ["tenantFiles/**/*.js"] }
+]
+
+
+[[migrations]]
+tag = "v1"

package/src/commands/PLUGINNAME/index.js

@@ -1,32 +0,0 @@
-/*
-Copyright 2020 Adobe. All rights reserved.
-This file is licensed to you under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License. You may obtain a copy
-of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under
-the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
-OF ANY KIND, either express or implied. See the License for the specific language
-governing permissions and limitations under the License.
-*/
-
-const { Command, flags } = require('@oclif/command');
-const aioLogger = require('@adobe/aio-lib-core-logging')('PLUGINNAME', { provider: 'debug' });
-
-class IndexCommand extends Command {
-	async run() {
-		// const { args, flags } = this.parse(IndexCommand)
-		aioLogger.debug('this is the index command.');
-	}
-}
-
-IndexCommand.flags = {
-	someflag: flags.string({ char: 'f', description: 'this is some flag' }),
-};
-
-// this is set in package.json, see https://github.com/oclif/oclif/issues/120
-// if not set it will get the first (alphabetical) topic's help description
-IndexCommand.description = 'Your description here';
-IndexCommand.examples = ['$ aio PLUGINNAME:some_command'];
-
-module.exports = IndexCommand;