@appsemble/cli 0.20.9 → 0.20.12

package/lib/getBlockConfigFromTypeScript.test.ts

@@ -0,0 +1,281 @@
+import { readdirSync } from 'fs';
+import { join, resolve } from 'path';
+
+import { AppsembleError, resolveFixture } from '@appsemble/node-utils';
+import ts from 'typescript';
+
+import { getBlockConfigFromTypeScript } from './getBlockConfigFromTypeScript';
+
+beforeEach(() => {
+  jest.spyOn(process, 'cwd').mockReturnValue(resolveFixture('.'));
+});
+
+describe('getBlockConfigFromTypeScript', () => {
+  it('should extract configuration from a TypeScript project', () => {
+    const result = getBlockConfigFromTypeScript({
+      name: '',
+      layout: 'float',
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+    });
+    expect(result).toStrictEqual({
+      actions: { testAction: { description: undefined } },
+      events: {
+        emit: { testEmit: { description: undefined } },
+        listen: { testListener: { description: undefined } },
+      },
+      messages: undefined,
+      parameters: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        additionalProperties: false,
+        properties: {
+          param1: { type: 'string' },
+          param2: { type: 'number' },
+          param3: { type: 'boolean' },
+          param4: { type: 'string' },
+          param5: {
+            additionalProperties: false,
+            properties: {
+              nested1: { type: 'string' },
+              nested2: { type: 'number' },
+              nested3: { type: 'boolean' },
+            },
+            required: ['nested1', 'nested2', 'nested3'],
+            type: 'object',
+          },
+          param6: { items: { type: 'string' }, type: 'array' },
+        },
+        required: ['param1', 'param2', 'param3', 'param5', 'param6'],
+        type: 'object',
+      },
+    });
+  });
+
+  it('should not use TypeScript if all metadata is present in the original config', () => {
+    jest.spyOn(ts, 'createProgram');
+    const input = {
+      actions: {},
+      events: { emit: { foo: {} }, listen: { bar: {} } },
+      layout: 'float',
+      parameters: { type: 'object' },
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+      name: '',
+    } as const;
+    const result = getBlockConfigFromTypeScript(input);
+
+    expect(result).toBe(input);
+    expect(ts.createProgram).not.toHaveBeenCalled();
+  });
+
+  it('should prefer actions overrides over TypeScript actions', () => {
+    const result = getBlockConfigFromTypeScript({
+      actions: {},
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+      name: '',
+    });
+
+    expect(result.actions).toStrictEqual({});
+  });
+
+  it('should prefer events overrides over TypeScript events', () => {
+    const result = getBlockConfigFromTypeScript({
+      events: { emit: { onSuccess: {} } },
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+      name: '',
+    });
+
+    expect(result.events).toStrictEqual({ emit: { onSuccess: {} } });
+  });
+
+  it('should prefer parameters overrides over TypeScript parameters', () => {
+    const result = getBlockConfigFromTypeScript({
+      parameters: { type: 'object' },
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+      name: '',
+    });
+
+    expect(result.parameters).toStrictEqual({ type: 'object' });
+  });
+
+  it('should throw if duplicate Actions are found', () => {
+    expect(() =>
+      getBlockConfigFromTypeScript({
+        webpack: '',
+        output: '',
+        dir: resolveFixture('getBlockConfigFromTypeScript/duplicateActions'),
+        name: '',
+        version: '1.33.7',
+      }),
+    ).toThrow(
+      new AppsembleError(
+        "Found duplicate interface 'Actions' in 'getBlockConfigFromTypeScript/duplicateActions/index.ts:31'",
+      ),
+    );
+  });
+
+  it('should throw if duplicate EventEmitters are found', () => {
+    expect(() =>
+      getBlockConfigFromTypeScript({
+        webpack: '',
+        output: '',
+        dir: resolveFixture('getBlockConfigFromTypeScript/duplicateEventEmitters'),
+        name: '',
+        version: '1.33.7',
+      }),
+    ).toThrow(
+      new AppsembleError(
+        "Found duplicate interface 'EventEmitters' in 'getBlockConfigFromTypeScript/duplicateEventEmitters/index.ts:31'",
+      ),
+    );
+  });
+
+  it('should throw if duplicate EventListeners are found', () => {
+    expect(() =>
+      getBlockConfigFromTypeScript({
+        webpack: '',
+        output: '',
+        dir: resolveFixture('getBlockConfigFromTypeScript/duplicateEventListeners'),
+        name: '',
+        version: '1.33.7',
+      }),
+    ).toThrow(
+      new AppsembleError(
+        "Found duplicate interface 'EventListeners' in 'getBlockConfigFromTypeScript/duplicateEventListeners/index.ts:31'",
+      ),
+    );
+  });
+
+  it('should throw if duplicate Parameters are found', () => {
+    expect(() =>
+      getBlockConfigFromTypeScript({
+        webpack: '',
+        output: '',
+        dir: resolveFixture('getBlockConfigFromTypeScript/duplicateParameters'),
+        name: '',
+        version: '1.33.7',
+      }),
+    ).toThrow(
+      new AppsembleError(
+        "Found duplicate interface 'Parameters' in 'getBlockConfigFromTypeScript/duplicateParameters/index.ts:31'",
+      ),
+    );
+  });
+
+  it('should handle fontawesome icons', () => {
+    const result = getBlockConfigFromTypeScript({
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/fontawesomeParameters'),
+      name: '',
+      version: '1.33.7',
+    });
+
+    expect(result).toStrictEqual({
+      actions: undefined,
+      events: undefined,
+      messages: undefined,
+      parameters: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        additionalProperties: false,
+        properties: {
+          icon: { description: 'This is an icon.', format: 'fontawesome', type: 'string' },
+        },
+        type: 'object',
+      },
+    });
+  });
+
+  it('should handle TypeScript pre emit diagnostics', () => {
+    function fn(): void {
+      getBlockConfigFromTypeScript({
+        name: '',
+        layout: 'float',
+        version: '1.33.7',
+        webpack: '',
+        output: '',
+        dir: resolveFixture('getBlockConfigFromTypeScript/tsError'),
+      });
+    }
+    expect(fn).toThrow(AppsembleError);
+    expect(fn).toThrow(/'unused' is declared but its value is never read/);
+  });
+
+  it('should extract comments', () => {
+    const result = getBlockConfigFromTypeScript({
+      name: '',
+      layout: 'float',
+      version: '1.33.7',
+      webpack: '',
+      output: '',
+      dir: resolveFixture('getBlockConfigFromTypeScript/comments'),
+    });
+
+    expect(result).toStrictEqual({
+      actions: {
+        comment: {
+          description: 'Valid action comment',
+        },
+        duplicate: {
+          description: 'Expected comment',
+        },
+        line: {
+          description: undefined,
+        },
+      },
+      events: {
+        emit: {
+          testEmit: {
+            description: 'Test event emitter.',
+          },
+        },
+        listen: {
+          testListener: {
+            description: 'Test event listener.',
+          },
+        },
+      },
+      messages: undefined,
+      parameters: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        additionalProperties: false,
+        properties: {
+          param: {},
+        },
+        required: ['param'],
+        type: 'object',
+      },
+    });
+  });
+
+  describe('official blocks', () => {
+    const blocksDir = resolve(__dirname, '..', '..', '..', 'blocks');
+
+    it.each(readdirSync(blocksDir))('%s', (name) => {
+      const dir = join(blocksDir, name);
+
+      const result = getBlockConfigFromTypeScript({
+        name,
+        version: '',
+        output: '',
+        webpack: undefined,
+        dir,
+      });
+
+      expect(result).toMatchSnapshot();
+    });
+  });
+});

package/lib/getBlockConfigFromTypeScript.ts

@@ -0,0 +1,354 @@
+import { relative } from 'path';
+
+import { AppsembleError, logger } from '@appsemble/node-utils';
+import { BlockConfig, BlockManifest } from '@appsemble/types';
+import { parse } from 'comment-parser';
+import { Schema } from 'jsonschema';
+import normalizePath from 'normalize-path';
+import { createFormatter, createParser, SchemaGenerator } from 'ts-json-schema-generator';
+import ts from 'typescript';
+
+/**
+ * Get the tsdoc comment for a TypeScript node.
+ *
+ * @param checker The type checker instance to use.
+ * @param node The node for which to get the tsdoc.
+ * @returns The tsdoc comment as a string, if present.
+ */
+function getNodeComments(checker: ts.TypeChecker, node: ts.TypeElement): string {
+  const symbol = checker.getSymbolAtLocation(node.name);
+  if (!symbol) {
+    return;
+  }
+
+  const comments = symbol.getDocumentationComment(checker);
+  if (comments.length) {
+    return comments
+      .map((comment) =>
+        comment.kind === 'lineBreak' ? comment.text : comment.text.trim().replace(/\r\n/g, '\n'),
+      )
+      .join('');
+  }
+}
+
+/**
+ * Process keys from an interface into an object.
+ *
+ * This asserts only index signature members and regular alphanumerical properties are used.
+ *
+ * @param iface The TypeScript interface to check.
+ * @param checker The TypeScript type checker.
+ * @param convert A function for converting extracted data to a value. It will be called with the
+ * name and JSDoc description. The name is `undefined` for index signatures. The function should
+ * return a tuple of key and value.
+ * @returns A record created from the returned key/value pairs.
+ */
+function processInterface<T>(
+  iface: ts.InterfaceDeclaration,
+  checker: ts.TypeChecker,
+  convert: (name: string, description: string) => [string, T],
+): Record<string, T> {
+  if (!iface?.members.length) {
+    return;
+  }
+
+  const source = iface.getSourceFile().getText();
+
+  return Object.fromEntries(
+    iface.members.map((member) => {
+      const description = getNodeComments(checker, member);
+      if (ts.isIndexSignatureDeclaration(member)) {
+        // Comments aren’t properly extracted for index signatures.
+        const commentRanges = ts.getLeadingCommentRanges(source, member.pos);
+        if (commentRanges) {
+          const comments = commentRanges?.map((r) => source.slice(r.pos, r.end)) ?? [];
+          const [block] = parse(comments[0]);
+          const processedDescription = block.source
+            .map((src) => src.tokens.description)
+            .join('\n')
+            .replace(/^\s+|\s+$/g, '');
+
+          return convert(undefined, processedDescription);
+        }
+
+        return convert(undefined, description);
+      }
+
+      if (!ts.isPropertySignature(member)) {
+        throw new AppsembleError(
+          `Only property and index signatures are allowed as ${
+            iface.name
+          } keys. Found: ${member.getFullText()}`,
+        );
+      }
+
+      const { name } = member;
+
+      if (!ts.isIdentifier(name)) {
+        throw new AppsembleError(
+          `Only property and index signatures are allowed as ${
+            iface.name
+          } keys. Found: ${name.getFullText()}`,
+        );
+      }
+
+      const { text } = name;
+
+      if (!/^[\da-z]+$/i.test(text)) {
+        throw new AppsembleError(
+          `Found property named ‘${text}’ in ${iface.name} interface. Only alphanumerical identifiers are supported.`,
+        );
+      }
+
+      return convert(text, description);
+    }),
+  );
+}
+
+/**
+ * Get an actions object based on a TypeScript interface node.
+ *
+ * @param iface The node to base the actions on.
+ * @param checker The TypeScript type checker.
+ * @returns The action manifest to upload.
+ */
+function processActions(
+  iface: ts.InterfaceDeclaration,
+  checker: ts.TypeChecker,
+): BlockManifest['actions'] {
+  return processInterface(iface, checker, (name, description) => [name ?? '$any', { description }]);
+}
+
+/**
+ * Get an events object based on TypeScript interface nodes.
+ *
+ * @param eventListenerInterface The node to base the event listeners on.
+ * @param eventEmitterInterface The node to base the event emitters on.
+ * @param checker The TypeScript type checker.
+ * @returns The events manifest to upload.
+ */
+function processEvents(
+  eventListenerInterface: ts.InterfaceDeclaration,
+  eventEmitterInterface: ts.InterfaceDeclaration,
+  checker: ts.TypeChecker,
+): BlockManifest['events'] {
+  const listen = processInterface(eventListenerInterface, checker, (name, description) => [
+    name ?? '$any',
+    { description },
+  ]);
+  const emit = processInterface(eventEmitterInterface, checker, (name, description) => [
+    name ?? '$any',
+    { description },
+  ]);
+
+  return (emit || listen) && { emit, listen };
+}
+
+/**
+ * Get the JSON schema for parameters based on a TypeScript program.
+ *
+ * @param program The TypeScript program from which to extract parameters.
+ * @param iface The interface node from which to extract parameters.
+ * @returns The JSON schema for the block parameters.
+ */
+function processParameters(program: ts.Program, iface: ts.InterfaceDeclaration): Schema {
+  if (!iface) {
+    return;
+  }
+  const formatter = createFormatter({}, (fmt) => {
+    fmt.addTypeFormatter({
+      supportsType: (type) => type.getName() === 'IconName',
+      getDefinition: () => ({ type: 'string', format: 'fontawesome' }),
+      getChildren: () => [],
+    });
+    fmt.addTypeFormatter({
+      supportsType: (type) => type.getName() === 'Remapper',
+      getDefinition: () => ({ format: 'remapper' }),
+      getChildren: () => [],
+    });
+  });
+  const parser = createParser(program, { expose: 'all', topRef: false });
+  const generator = new SchemaGenerator(program, parser, formatter);
+  const schema = generator.createSchemaFromNodes([iface]) as Schema;
+  if (schema.definitions && !Object.keys(schema.definitions).length) {
+    delete schema.definitions;
+  }
+  // This is the tsdoc that has been added to the SDK to aid the block developer.
+  delete schema.description;
+  return schema;
+}
+
+/**
+ * Get a messages object based on a TypeScript interface node.
+ *
+ * @param iface The node to base the messages on.
+ * @param checker The TypeScript type checker.
+ * @returns The action manifest to upload.
+ */
+function processMessages(
+  iface: ts.InterfaceDeclaration,
+  checker: ts.TypeChecker,
+): BlockManifest['messages'] {
+  return processInterface(iface, checker, (name, description) => [name, { description }]);
+}
+
+/**
+ * Get the TypeScript program for a given path.
+ *
+ * @param blockPath The path for which to get the TypeScript program.
+ * @returns The TypeScript program.
+ */
+function getProgram(blockPath: string): ts.Program {
+  const diagnosticHost: ts.FormatDiagnosticsHost = {
+    getNewLine: () => ts.sys.newLine,
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getCanonicalFileName: (x) => x,
+  };
+  const tsConfigPath = ts.findConfigFile(blockPath, ts.sys.fileExists);
+  const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+  if (error) {
+    throw new AppsembleError(ts.formatDiagnostic(error, diagnosticHost));
+  }
+  if (!config.files || !config.include) {
+    config.files = ts.sys
+      .readDirectory(blockPath, ['.ts', '.tsx'])
+      .map((f) => relative(blockPath, f));
+  }
+  const { errors, fileNames, options } = ts.parseJsonConfigFileContent(
+    config,
+    ts.sys,
+    blockPath,
+    undefined,
+    tsConfigPath,
+  );
+  // Filter: 'rootDir' is expected to contain all source files.
+  const diagnostics = errors.filter(({ code }) => code !== 6059);
+  if (diagnostics.length) {
+    throw new AppsembleError(ts.formatDiagnosticsWithColorAndContext(diagnostics, diagnosticHost));
+  }
+
+  options.noEmit = true;
+  delete options.out;
+  delete options.outDir;
+  delete options.outFile;
+  delete options.declaration;
+  delete options.declarationDir;
+  delete options.declarationMap;
+  const program = ts.createProgram(fileNames, options);
+  const preEmitDiagnostics = ts.getPreEmitDiagnostics(program);
+  if (preEmitDiagnostics.length) {
+    throw new AppsembleError(
+      ts.formatDiagnosticsWithColorAndContext(preEmitDiagnostics, diagnosticHost),
+    );
+  }
+  return program;
+}
+
+/**
+ * Generate a block manifest from the block metadata and TypeScript project.
+ *
+ * Uses the .appsemblerc file and the type definitions of the block.
+ *
+ * @param blockConfig The block configuration
+ * @returns The block configuration appended from the TypeScript project.
+ */
+export function getBlockConfigFromTypeScript(
+  blockConfig: BlockConfig,
+): Pick<BlockManifest, 'actions' | 'events' | 'messages' | 'parameters'> {
+  if ('actions' in blockConfig && 'events' in blockConfig && 'parameters' in blockConfig) {
+    return blockConfig;
+  }
+  logger.info(`Extracting data from TypeScript project ${blockConfig.dir}`);
+  const program = getProgram(blockConfig.dir);
+  const checker = program.getTypeChecker();
+
+  let actionInterface: ts.InterfaceDeclaration;
+  let eventEmitterInterface: ts.InterfaceDeclaration;
+  let eventListenerInterface: ts.InterfaceDeclaration;
+  let messagesInterface: ts.InterfaceDeclaration;
+  let patametersInterface: ts.InterfaceDeclaration;
+
+  for (const sourceFile of program.getSourceFiles()) {
+    const fileName = relative(process.cwd(), sourceFile.fileName);
+    // Filter TypeScript default libs
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+      logger.silly(`Skipping metadata extraction from: ${fileName}`);
+      continue;
+    }
+    logger.verbose(`Searching metadata in: ${fileName}`);
+    // eslint-disable-next-line @typescript-eslint/no-loop-func
+    ts.forEachChild(sourceFile, (mod) => {
+      // This node doesn’t override SDK types
+      if (!ts.isModuleDeclaration(mod)) {
+        return;
+      }
+      // This module defines other types
+      if (mod.name.text !== '@appsemble/sdk') {
+        return;
+      }
+      ts.forEachChild(mod.body, (iface) => {
+        // Appsemble only uses module interface augmentation.
+        if (!ts.isInterfaceDeclaration(iface)) {
+          return;
+        }
+        const { line } = sourceFile.getLineAndCharacterOfPosition(iface.getStart(sourceFile));
+        // Line numbers are 0 indexed, whereas they are usually represented as 1 indexed.
+        const loc = `${normalizePath(fileName)}:${line + 1}`;
+
+        switch (iface.name.text) {
+          case 'Actions':
+            logger.info(`Found augmented interface 'Actions' in '${loc}'`);
+            if (actionInterface) {
+              throw new AppsembleError(`Found duplicate interface 'Actions' in '${loc}'`);
+            }
+            actionInterface = iface;
+            break;
+          case 'EventEmitters':
+            logger.info(`Found augmented interface 'EventEmitters' in '${loc}'`);
+            if (eventEmitterInterface) {
+              throw new AppsembleError(`Found duplicate interface 'EventEmitters' in '${loc}'`);
+            }
+            eventEmitterInterface = iface;
+            break;
+          case 'EventListeners':
+            logger.info(`Found augmented interface 'EventListeners' in '${loc}'`);
+            if (eventListenerInterface) {
+              throw new AppsembleError(`Found duplicate interface 'EventListeners' in '${loc}'`);
+            }
+            eventListenerInterface = iface;
+            break;
+          case 'Parameters':
+            logger.info(`Found augmented interface 'Parameters' in '${loc}'`);
+            if (patametersInterface) {
+              throw new AppsembleError(`Found duplicate interface 'Parameters' in '${loc}'`);
+            }
+            patametersInterface = iface;
+            break;
+          case 'Messages':
+            logger.info(`Found augmented interface 'Messages' in '${loc}'`);
+            messagesInterface = iface;
+            break;
+          default:
+            logger.warn(`Detected unused augmented type ${iface.name.text} in ${loc}`);
+        }
+      });
+    });
+  }
+
+  return {
+    actions:
+      'actions' in blockConfig ? blockConfig.actions : processActions(actionInterface, checker),
+    events:
+      'events' in blockConfig
+        ? blockConfig.events
+        : processEvents(eventListenerInterface, eventEmitterInterface, checker),
+    parameters:
+      'parameters' in blockConfig
+        ? blockConfig.parameters
+        : processParameters(program, patametersInterface),
+    messages:
+      'messages' in blockConfig
+        ? blockConfig.messages
+        : processMessages(messagesInterface, checker),
+  };
+}

package/{dist/lib → lib}/initAxios.d.ts

@@ -2,6 +2,6 @@ import { BaseArguments } from '../types';
 /**
  * Configure the default axios URL.
  *
- * @param argv - The parsed command line arguments.
+ * @param argv The parsed command line arguments.
  */
 export declare function initAxios({ remote }: BaseArguments): void;

package/{dist/lib → lib}/initAxios.js

@@ -6,17 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initAxios = void 0;
 const node_utils_1 = require("@appsemble/node-utils");
 const axios_1 = __importDefault(require("axios"));
-const readPackageJson_1 = require("./readPackageJson");
+const package_json_1 = __importDefault(require("../package.json"));
 /**
  * Configure the default axios URL.
  *
- * @param argv - The parsed command line arguments.
+ * @param argv The parsed command line arguments.
  */
 function initAxios({ remote }) {
-    const { version } = (0, readPackageJson_1.readPackageJson)();
     axios_1.default.defaults.baseURL = remote;
     node_utils_1.logger.verbose(`Request remote set to ${remote}`);
-    (0, node_utils_1.configureAxios)('AppsembleCLI', version);
+    (0, node_utils_1.configureAxios)('AppsembleCLI', package_json_1.default.version);
 }
 exports.initAxios = initAxios;
 //# sourceMappingURL=initAxios.js.map

package/lib/initAxios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initAxios.js","sourceRoot":"","sources":["initAxios.ts"],"names":[],"mappings":";;;;;;AAAA,sDAA+D;AAC/D,kDAA0B;AAE1B,mEAAkC;AAGlC;;;;GAIG;AACH,SAAgB,SAAS,CAAC,EAAE,MAAM,EAAiB;IACjD,eAAK,CAAC,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC;IAChC,mBAAM,CAAC,OAAO,CAAC,yBAAyB,MAAM,EAAE,CAAC,CAAC;IAClD,IAAA,2BAAc,EAAC,cAAc,EAAE,sBAAG,CAAC,OAAO,CAAC,CAAC;AAC9C,CAAC;AAJD,8BAIC"}

package/lib/initAxios.ts

@@ -0,0 +1,16 @@
+import { configureAxios, logger } from '@appsemble/node-utils';
+import axios from 'axios';
+
+import pkg from '../package.json';
+import { BaseArguments } from '../types';
+
+/**
+ * Configure the default axios URL.
+ *
+ * @param argv The parsed command line arguments.
+ */
+export function initAxios({ remote }: BaseArguments): void {
+  axios.defaults.baseURL = remote;
+  logger.verbose(`Request remote set to ${remote}`);
+  configureAxios('AppsembleCLI', pkg.version);
+}

package/{dist/lib → lib}/loadWebpackConfig.d.ts

@@ -7,9 +7,9 @@ import { Configuration } from 'webpack';
  * or asynchronous function which returns a webpack configuration object. This function supports
  * all 3 use cases.
  *
- * @param block - The path to the webpack configuration file.
- * @param mode - The env that would be passed to webpack by invoking `webpack --env $env`.
- * @param outputPath - The path where the build will be output on disk.
+ * @param block The path to the webpack configuration file.
+ * @param mode The env that would be passed to webpack by invoking `webpack --env $env`.
+ * @param outputPath The path where the build will be output on disk.
  * @returns The webpack configuration as exposed by the webpack configuration file.
  */
 export declare function loadWebpackConfig(block: BlockConfig, mode?: 'development' | 'production', outputPath?: string): Promise<Configuration>;