@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/io/private/sdk-logger.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asSdkLogger = asSdkLogger;
 const util_1 = require("util");
-const util_2 = require("../../../private/util");
-const shared_private_1 = require("../../shared-private");
+const messages_1 = require("./messages");
+const util_2 = require("../../../util");
 function asSdkLogger(ioHost) {
     return new class {
         // This is too much detail for our logs
@@ -39,13 +39,13 @@ function asSdkLogger(ioHost) {
          * ```
          */
         info(...content) {
-            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {
+            void ioHost.notify(messages_1.IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {
                 sdkLevel: 'info',
                 content,
             }));
         }
         warn(...content) {
-            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {
+            void ioHost.notify(messages_1.IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {
                 sdkLevel: 'warn',
                 content,
             }));
@@ -72,7 +72,7 @@ function asSdkLogger(ioHost) {
          * ```
          */
         error(...content) {
-            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {
+            void ioHost.notify(messages_1.IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {
                 sdkLevel: 'error',
                 content,
             }));
@@ -121,4 +121,4 @@ function isSdkApiCallSuccess(x) {
 function isSdkApiCallError(x) {
     return x && typeof x === 'object' && x.commandName && x.error;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["sdk-logger.ts"],"names":[],"mappings":";;AAOA,kCA6EC;AAnFD,+BAA+B;AAE/B,gDAA+D;AAE/D,yDAA0C;AAE1C,SAAgB,WAAW,CAAC,MAAgB;IAC1C,OAAO,IAAI;QACT,uCAAuC;QAChC,KAAK,CAAC,GAAG,QAAe;QAC/B,CAAC;QACM,KAAK,CAAC,GAAG,QAAe;QAC/B,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACI,IAAI,CAAC,GAAG,OAAc;YAC3B,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAE,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACvF,QAAQ,EAAE,MAAM;gBAChB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;QAEM,IAAI,CAAC,GAAG,OAAc;YAC3B,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAE,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACvF,QAAQ,EAAE,MAAM;gBAChB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACI,KAAK,CAAC,GAAG,OAAc;YAC5B,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAE,CAAC,aAAa,CAAC,GAAG,CAAC,eAAe,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACxF,QAAQ,EAAE,OAAO;gBACjB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,sBAAsB,CAAC,OAAc;IAC5C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAA,cAAO,EAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,aAAa,CAAC,OAAY;IACjC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC;QACjE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC1D,MAAM,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAExD,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE,QAAQ,cAAc,OAAO,CAAC,QAAQ,EAAE,eAAe,WAAW,CAAC,CAAC;IACvG,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,6BAAsB,CAAC,GAAG,CAAC,CAAC;IAE1F,IAAI,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC;QACjC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAmBD,SAAS,mBAAmB,CAAC,CAAM;IACjC,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,MAAM,CAAC;AACjE,CAAC;AAED,SAAS,iBAAiB,CAAC,CAAM;IAC/B,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,KAAK,CAAC;AAChE,CAAC","sourcesContent":["\nimport { inspect } from 'util';\nimport type { Logger } from '@smithy/types';\nimport { replacerBufferWithInfo } from '../../../private/util';\nimport type { IoHelper } from '../../shared-private';\nimport { IO } from '../../shared-private';\n\nexport function asSdkLogger(ioHost: IoHelper): Logger {\n  return new class implements Logger {\n    // This is too much detail for our logs\n    public trace(..._content: any[]) {\n    }\n    public debug(..._content: any[]) {\n    }\n\n    /**\n     * Info is called mostly (exclusively?) for successful API calls\n     *\n     * Payload:\n     *\n     * (Note the input contains entire CFN templates, for example)\n     *\n     * ```\n     * {\n     *   clientName: 'S3Client',\n     *   commandName: 'GetBucketLocationCommand',\n     *   input: {\n     *     Bucket: '.....',\n     *     ExpectedBucketOwner: undefined\n     *   },\n     *   output: { LocationConstraint: 'eu-central-1' },\n     *   metadata: {\n     *     httpStatusCode: 200,\n     *     requestId: '....',\n     *     extendedRequestId: '...',\n     *     cfId: undefined,\n     *     attempts: 1,\n     *     totalRetryDelay: 0\n     *   }\n     * }\n     * ```\n     */\n    public info(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'info',\n        content,\n      }));\n    }\n\n    public warn(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'warn',\n        content,\n      }));\n    }\n\n    /**\n     * Error is called mostly (exclusively?) for failing API calls\n     *\n     * Payload (input would be the entire API call arguments).\n     *\n     * ```\n     * {\n     *   clientName: 'STSClient',\n     *   commandName: 'GetCallerIdentityCommand',\n     *   input: {},\n     *   error: AggregateError [ECONNREFUSED]:\n     *       at internalConnectMultiple (node:net:1121:18)\n     *       at afterConnectMultiple (node:net:1688:7) {\n     *     code: 'ECONNREFUSED',\n     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n     *     [errors]: [ [Error], [Error] ]\n     *   },\n     *   metadata: { attempts: 3, totalRetryDelay: 600 }\n     * }\n     * ```\n     */\n    public error(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'error',\n        content,\n      }));\n    }\n  };\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nfunction formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["sdk-logger.ts"],"names":[],"mappings":";;AAOA,kCA6EC;AAnFD,+BAA+B;AAG/B,yCAAgC;AAChC,wCAAuD;AAEvD,SAAgB,WAAW,CAAC,MAAgB;IAC1C,OAAO,IAAI;QACT,uCAAuC;QAChC,KAAK,CAAC,GAAG,QAAe;QAC/B,CAAC;QACM,KAAK,CAAC,GAAG,QAAe;QAC/B,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACI,IAAI,CAAC,GAAG,OAAc;YAC3B,KAAK,MAAM,CAAC,MAAM,CAAC,aAAE,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACvF,QAAQ,EAAE,MAAM;gBAChB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;QAEM,IAAI,CAAC,GAAG,OAAc;YAC3B,KAAK,MAAM,CAAC,MAAM,CAAC,aAAE,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACvF,QAAQ,EAAE,MAAM;gBAChB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACI,KAAK,CAAC,GAAG,OAAc;YAC5B,KAAK,MAAM,CAAC,MAAM,CAAC,aAAE,CAAC,aAAa,CAAC,GAAG,CAAC,eAAe,sBAAsB,CAAC,OAAO,CAAC,EAAE,EAAE;gBACxF,QAAQ,EAAE,OAAO;gBACjB,OAAO;aACR,CAAC,CAAC,CAAC;QACN,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,sBAAsB,CAAC,OAAc;IAC5C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAA,cAAO,EAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,aAAa,CAAC,OAAY;IACjC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC;QACjE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC1D,MAAM,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAExD,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE,QAAQ,cAAc,OAAO,CAAC,QAAQ,EAAE,eAAe,WAAW,CAAC,CAAC;IACvG,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,6BAAsB,CAAC,GAAG,CAAC,CAAC;IAE1F,IAAI,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC;QACjC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAmBD,SAAS,mBAAmB,CAAC,CAAM;IACjC,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,MAAM,CAAC;AACjE,CAAC;AAED,SAAS,iBAAiB,CAAC,CAAM;IAC/B,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,KAAK,CAAC;AAChE,CAAC","sourcesContent":["\nimport { inspect } from 'util';\nimport type { Logger } from '@smithy/types';\nimport type { IoHelper } from './io-helper';\nimport { IO } from './messages';\nimport { replacerBufferWithInfo } from '../../../util';\n\nexport function asSdkLogger(ioHost: IoHelper): Logger {\n  return new class implements Logger {\n    // This is too much detail for our logs\n    public trace(..._content: any[]) {\n    }\n    public debug(..._content: any[]) {\n    }\n\n    /**\n     * Info is called mostly (exclusively?) for successful API calls\n     *\n     * Payload:\n     *\n     * (Note the input contains entire CFN templates, for example)\n     *\n     * ```\n     * {\n     *   clientName: 'S3Client',\n     *   commandName: 'GetBucketLocationCommand',\n     *   input: {\n     *     Bucket: '.....',\n     *     ExpectedBucketOwner: undefined\n     *   },\n     *   output: { LocationConstraint: 'eu-central-1' },\n     *   metadata: {\n     *     httpStatusCode: 200,\n     *     requestId: '....',\n     *     extendedRequestId: '...',\n     *     cfId: undefined,\n     *     attempts: 1,\n     *     totalRetryDelay: 0\n     *   }\n     * }\n     * ```\n     */\n    public info(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'info',\n        content,\n      }));\n    }\n\n    public warn(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'warn',\n        content,\n      }));\n    }\n\n    /**\n     * Error is called mostly (exclusively?) for failing API calls\n     *\n     * Payload (input would be the entire API call arguments).\n     *\n     * ```\n     * {\n     *   clientName: 'STSClient',\n     *   commandName: 'GetCallerIdentityCommand',\n     *   input: {},\n     *   error: AggregateError [ECONNREFUSED]:\n     *       at internalConnectMultiple (node:net:1121:18)\n     *       at afterConnectMultiple (node:net:1688:7) {\n     *     code: 'ECONNREFUSED',\n     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n     *     [errors]: [ [Error], [Error] ]\n     *   },\n     *   metadata: { attempts: 3, totalRetryDelay: 600 }\n     * }\n     * ```\n     */\n    public error(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'error',\n        content,\n      }));\n    }\n  };\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nfunction formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]}

package/lib/api/io/private/span.d.ts

@@ -0,0 +1,93 @@
+import type { ActionLessMessage, IoHelper } from './io-helper';
+import type { IoMessageMaker } from './message-maker';
+import type { Duration } from '../../../payloads/types';
+export interface SpanEnd {
+    readonly duration: number;
+}
+/**
+ * Describes a specific span
+ *
+ * A span definition is a pair of `IoMessageMaker`s to create a start and end message of the span respectively.
+ * It also has a display name, that is used for auto-generated message text when they are not provided.
+ */
+export interface SpanDefinition<S extends object, E extends SpanEnd> {
+    readonly name: string;
+    readonly start: IoMessageMaker<S>;
+    readonly end: IoMessageMaker<E>;
+}
+/**
+ * Used in conditional types to check if a type (e.g. after omitting fields) is an empty object
+ * This is needed because counter-intuitive neither `object` nor `{}` represent that.
+ */
+type EmptyObject = {
+    [index: string | number | symbol]: never;
+};
+/**
+ * Helper type to force a parameter to be not present of the computed type is an empty object
+ */
+type VoidWhenEmpty<T> = T extends EmptyObject ? void : T;
+/**
+ * Helper type to force a parameter to be an empty object if the computed type is an empty object
+ * This is weird, but some computed types (e.g. using `Omit`) don't end up enforcing this.
+ */
+type ForceEmpty<T> = T extends EmptyObject ? EmptyObject : T;
+/**
+ * Make some properties optional
+ */
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+/**
+ * Ending the span returns the observed duration
+ */
+interface ElapsedTime {
+    readonly asMs: number;
+    readonly asSec: number;
+}
+/**
+ * A message span that can be ended and read times from
+ */
+export interface IMessageSpan<E extends SpanEnd> {
+    /**
+     * Get the time elapsed since the start
+     */
+    elapsedTime(): Promise<ElapsedTime>;
+    /**
+     * Sends a simple, generic message with the current timing
+     * For more complex intermediate messages, get the `elapsedTime` and use `notify`
+     */
+    timing(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime>;
+    /**
+     * Sends an arbitrary intermediate message as part of the span
+     */
+    notify(message: ActionLessMessage<unknown>): Promise<void>;
+    /**
+     * End the span with a payload
+     */
+    end(payload: VoidWhenEmpty<Omit<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+    /**
+     * End the span with a payload, overwriting
+     */
+    end(payload: VoidWhenEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+    /**
+     * End the span with a message and payload
+     */
+    end(message: string, payload: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+}
+/**
+ * Helper class to make spans around blocks of work
+ *
+ * Blocks are enclosed by a start and end message.
+ * All messages of the span share a unique id.
+ * The end message contains the time passed between start and end.
+ */
+export declare class SpanMaker<S extends object, E extends SpanEnd> {
+    private readonly definition;
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper, definition: SpanDefinition<S, E>);
+    /**
+     * Starts the span and initially notifies the IoHost
+     * @returns a message span
+     */
+    begin(payload: VoidWhenEmpty<S>): Promise<IMessageSpan<E>>;
+    begin(message: string, payload: S): Promise<IMessageSpan<E>>;
+}
+export {};

package/lib/api/io/private/span.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanMaker = void 0;
+const util = require("node:util");
+const uuid = require("uuid");
+const util_1 = require("../../../util");
+/**
+ * Helper class to make spans around blocks of work
+ *
+ * Blocks are enclosed by a start and end message.
+ * All messages of the span share a unique id.
+ * The end message contains the time passed between start and end.
+ */
+class SpanMaker {
+    definition;
+    ioHelper;
+    constructor(ioHelper, definition) {
+        this.definition = definition;
+        this.ioHelper = ioHelper;
+    }
+    async begin(a, b) {
+        const spanId = uuid.v4();
+        const startTime = new Date().getTime();
+        const notify = (msg) => {
+            return this.ioHelper.notify(withSpanId(spanId, msg));
+        };
+        const startInput = parseArgs(a, b);
+        const startMsg = startInput.message ?? `Starting ${this.definition.name} ...`;
+        const startPayload = startInput.payload;
+        await notify(this.definition.start.msg(startMsg, startPayload));
+        const timingMsgTemplate = '\n✨  %s time: %ds\n';
+        const time = () => {
+            const elapsedTime = new Date().getTime() - startTime;
+            return {
+                asMs: elapsedTime,
+                asSec: (0, util_1.formatTime)(elapsedTime),
+            };
+        };
+        return {
+            elapsedTime: async () => {
+                return time();
+            },
+            notify: async (msg) => {
+                await notify(msg);
+            },
+            timing: async (maker, message) => {
+                const duration = time();
+                const timingMsg = message ? message : util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+                await notify(maker.msg(timingMsg, {
+                    duration: duration.asMs,
+                }));
+                return duration;
+            },
+            end: async (x, y) => {
+                const duration = time();
+                const endInput = parseArgs(x, y);
+                const endMsg = endInput.message ?? util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+                const endPayload = endInput.payload;
+                await notify(this.definition.end.msg(endMsg, {
+                    duration: duration.asMs,
+                    ...endPayload,
+                }));
+                return duration;
+            },
+        };
+    }
+}
+exports.SpanMaker = SpanMaker;
+function parseArgs(first, second) {
+    const firstIsMessage = typeof first === 'string';
+    // When the first argument is a string or we have a second argument, then the first arg is the message
+    const message = (firstIsMessage || second) ? first : undefined;
+    // When the first argument is a string or we have a second argument,
+    // then the second arg is the payload, otherwise the first arg is the payload
+    const payload = (firstIsMessage || second) ? second : first;
+    return {
+        message,
+        payload,
+    };
+}
+function withSpanId(span, message) {
+    return {
+        ...message,
+        span,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"span.js","sourceRoot":"","sources":["span.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'node:util';\nimport * as uuid from 'uuid';\nimport type { ActionLessMessage, IoHelper } from './io-helper';\nimport type { IoMessageMaker } from './message-maker';\nimport type { Duration } from '../../../payloads/types';\nimport { formatTime } from '../../../util';\n\nexport interface SpanEnd {\n  readonly duration: number;\n}\n\n/**\n * Describes a specific span\n *\n * A span definition is a pair of `IoMessageMaker`s to create a start and end message of the span respectively.\n * It also has a display name, that is used for auto-generated message text when they are not provided.\n */\nexport interface SpanDefinition<S extends object, E extends SpanEnd> {\n  readonly name: string;\n  readonly start: IoMessageMaker<S>;\n  readonly end: IoMessageMaker<E>;\n}\n\n/**\n * Used in conditional types to check if a type (e.g. after omitting fields) is an empty object\n * This is needed because counter-intuitive neither `object` nor `{}` represent that.\n */\ntype EmptyObject = {\n  [index: string | number | symbol]: never;\n};\n\n/**\n * Helper type to force a parameter to be not present of the computed type is an empty object\n */\ntype VoidWhenEmpty<T> = T extends EmptyObject ? void : T;\n\n/**\n * Helper type to force a parameter to be an empty object if the computed type is an empty object\n * This is weird, but some computed types (e.g. using `Omit`) don't end up enforcing this.\n */\ntype ForceEmpty<T> = T extends EmptyObject ? EmptyObject : T;\n\n/**\n * Make some properties optional\n */\ntype Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;\n\n/**\n * Ending the span returns the observed duration\n */\ninterface ElapsedTime {\n  readonly asMs: number;\n  readonly asSec: number;\n}\n\n/**\n * A message span that can be ended and read times from\n */\nexport interface IMessageSpan<E extends SpanEnd> {\n  /**\n   * Get the time elapsed since the start\n   */\n  elapsedTime(): Promise<ElapsedTime>;\n  /**\n   * Sends a simple, generic message with the current timing\n   * For more complex intermediate messages, get the `elapsedTime` and use `notify`\n   */\n  timing(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime>;\n  /**\n   * Sends an arbitrary intermediate message as part of the span\n   */\n  notify(message: ActionLessMessage<unknown>): Promise<void>;\n  /**\n   * End the span with a payload\n   */\n  end(payload: VoidWhenEmpty<Omit<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n  /**\n   * End the span with a payload, overwriting\n   */\n  end(payload: VoidWhenEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n  /**\n   * End the span with a message and payload\n   */\n  end(message: string, payload: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n}\n\n/**\n * Helper class to make spans around blocks of work\n *\n * Blocks are enclosed by a start and end message.\n * All messages of the span share a unique id.\n * The end message contains the time passed between start and end.\n */\nexport class SpanMaker<S extends object, E extends SpanEnd> {\n  private readonly definition: SpanDefinition<S, E>;\n  private readonly ioHelper: IoHelper;\n\n  public constructor(ioHelper: IoHelper, definition: SpanDefinition<S, E>) {\n    this.definition = definition;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Starts the span and initially notifies the IoHost\n   * @returns a message span\n   */\n  public async begin(payload: VoidWhenEmpty<S>): Promise<IMessageSpan<E>>;\n  public async begin(message: string, payload: S): Promise<IMessageSpan<E>>;\n  public async begin(a: any, b?: S): Promise<IMessageSpan<E>> {\n    const spanId = uuid.v4();\n    const startTime = new Date().getTime();\n\n    const notify = (msg: ActionLessMessage<unknown>): Promise<void> => {\n      return this.ioHelper.notify(withSpanId(spanId, msg));\n    };\n\n    const startInput = parseArgs<S>(a, b);\n    const startMsg = startInput.message ?? `Starting ${this.definition.name} ...`;\n    const startPayload = startInput.payload;\n\n    await notify(this.definition.start.msg(\n      startMsg,\n      startPayload,\n    ));\n\n    const timingMsgTemplate = '\\n✨  %s time: %ds\\n';\n    const time = () => {\n      const elapsedTime = new Date().getTime() - startTime;\n      return {\n        asMs: elapsedTime,\n        asSec: formatTime(elapsedTime),\n      };\n    };\n\n    return {\n      elapsedTime: async (): Promise<ElapsedTime> => {\n        return time();\n      },\n\n      notify: async(msg: ActionLessMessage<unknown>): Promise<void> => {\n        await notify(msg);\n      },\n\n      timing: async(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime> => {\n        const duration = time();\n        const timingMsg = message ? message : util.format(timingMsgTemplate, this.definition.name, duration.asSec);\n        await notify(maker.msg(timingMsg, {\n          duration: duration.asMs,\n        }));\n        return duration;\n      },\n\n      end: async (x: any, y?: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime> => {\n        const duration = time();\n\n        const endInput = parseArgs<ForceEmpty<Optional<E, keyof SpanEnd>>>(x, y);\n        const endMsg = endInput.message ?? util.format(timingMsgTemplate, this.definition.name, duration.asSec);\n        const endPayload = endInput.payload;\n\n        await notify(this.definition.end.msg(\n          endMsg, {\n            duration: duration.asMs,\n            ...endPayload,\n          } as E));\n\n        return duration;\n      },\n    };\n  }\n}\n\nfunction parseArgs<S extends object>(first: any, second?: S): { message: string | undefined; payload: S } {\n  const firstIsMessage = typeof first === 'string';\n\n  // When the first argument is a string or we have a second argument, then the first arg is the message\n  const message = (firstIsMessage || second) ? first : undefined;\n\n  // When the first argument is a string or we have a second argument,\n  // then the second arg is the payload, otherwise the first arg is the payload\n  const payload = (firstIsMessage || second) ? second : first;\n\n  return {\n    message,\n    payload,\n  };\n}\n\nfunction withSpanId(span: string, message: ActionLessMessage<unknown>): ActionLessMessage<unknown> {\n  return {\n    ...message,\n    span,\n  };\n}\n"]}

package/lib/api/io/private/testing/fake-io-host.d.ts

@@ -0,0 +1,28 @@
+import type { IIoHost } from '../../io-host';
+import type { IoMessage, IoMessageLevel, IoRequest } from '../../io-message';
+/**
+ * An implementation of `IIoHost` that records messages and lets you assert on what was logged
+ *
+ * It's like `TestIoHost`, but comes with a predefined implementation for `notify`
+ * that appends all messages to an in-memory array, and comes with a helper function
+ * `expectMessage()` to test for the existence of a function in that array.
+ *
+ * Has a public mock for `requestResponse` that you configure like any
+ * other mock function.
+ *
+ * # How to use
+ *
+ * Either create a new instance of this class for every test, or call `clear()`
+ * on it between runs.
+ */
+export declare class FakeIoHost implements IIoHost {
+    messages: Array<IoMessage<unknown>>;
+    requestResponse: <T, U>(msg: IoRequest<T, U>) => Promise<U>;
+    constructor();
+    clear(): void;
+    notify(msg: IoMessage<unknown>): Promise<void>;
+    expectMessage(m: {
+        containing: string;
+        level?: IoMessageLevel;
+    }): void;
+}

package/lib/api/io/private/testing/fake-io-host.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeIoHost = void 0;
+/**
+ * An implementation of `IIoHost` that records messages and lets you assert on what was logged
+ *
+ * It's like `TestIoHost`, but comes with a predefined implementation for `notify`
+ * that appends all messages to an in-memory array, and comes with a helper function
+ * `expectMessage()` to test for the existence of a function in that array.
+ *
+ * Has a public mock for `requestResponse` that you configure like any
+ * other mock function.
+ *
+ * # How to use
+ *
+ * Either create a new instance of this class for every test, or call `clear()`
+ * on it between runs.
+ */
+class FakeIoHost {
+    messages = [];
+    requestResponse;
+    constructor() {
+        this.clear();
+    }
+    clear() {
+        this.messages.splice(0, this.messages.length);
+        this.requestResponse = jest.fn().mockRejectedValue(new Error('requestResponse not mocked'));
+    }
+    async notify(msg) {
+        this.messages.push(msg);
+    }
+    expectMessage(m) {
+        expect(this.messages).toContainEqual(expect.objectContaining({
+            ...m.level ? { level: m.level } : undefined,
+            // Can be a partial string as well
+            message: expect.stringContaining(m.containing),
+        }));
+    }
+}
+exports.FakeIoHost = FakeIoHost;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/io/private/testing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './test-io-host';
+export * from './fake-io-host';

package/lib/api/io/private/testing/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./test-io-host"), exports);
+__exportStar(require("./fake-io-host"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLGlEQUErQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGVzdC1pby1ob3N0JztcbmV4cG9ydCAqIGZyb20gJy4vZmFrZS1pby1ob3N0JztcbiJdfQ==

package/lib/api/io/private/testing/test-io-host.d.ts

@@ -0,0 +1,27 @@
+import { RequireApproval } from '../../../require-approval';
+import type { IIoHost } from '../../io-host';
+import type { IoMessage, IoMessageLevel, IoRequest } from '../../io-message';
+import type { IoHelper } from '../io-helper';
+/**
+ * A test implementation of IIoHost that does nothing but can be spied on.
+ *
+ * Includes a level to filter out irrelevant messages, defaults to `info`.
+ *
+ * Optionally set an approval level for code `CDK_TOOLKIT_I5060`.
+ *
+ * # How to use
+ *
+ * Configure and reset the `notifySpy` and `requestSpy` members as you would any
+ * mock function.
+ */
+export declare class TestIoHost implements IIoHost {
+    level: IoMessageLevel;
+    readonly notifySpy: jest.Mock<any, any, any>;
+    readonly requestSpy: jest.Mock<any, any, any>;
+    requireDeployApproval: RequireApproval;
+    constructor(level?: IoMessageLevel);
+    asHelper(action?: string): IoHelper;
+    notify(msg: IoMessage<unknown>): Promise<void>;
+    requestResponse<T, U>(msg: IoRequest<T, U>): Promise<U>;
+    private needsApproval;
+}

package/lib/api/io/private/testing/test-io-host.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestIoHost = void 0;
+const require_approval_1 = require("../../../require-approval");
+const io_helper_1 = require("../io-helper");
+const level_priority_1 = require("../level-priority");
+/**
+ * A test implementation of IIoHost that does nothing but can be spied on.
+ *
+ * Includes a level to filter out irrelevant messages, defaults to `info`.
+ *
+ * Optionally set an approval level for code `CDK_TOOLKIT_I5060`.
+ *
+ * # How to use
+ *
+ * Configure and reset the `notifySpy` and `requestSpy` members as you would any
+ * mock function.
+ */
+class TestIoHost {
+    level;
+    notifySpy;
+    requestSpy;
+    requireDeployApproval = require_approval_1.RequireApproval.NEVER;
+    constructor(level = 'info') {
+        this.level = level;
+        this.notifySpy = jest.fn();
+        this.requestSpy = jest.fn();
+    }
+    asHelper(action = 'synth') {
+        return (0, io_helper_1.asIoHelper)(this, action);
+    }
+    async notify(msg) {
+        if ((0, level_priority_1.isMessageRelevantForLevel)(msg, this.level)) {
+            this.notifySpy(msg);
+        }
+    }
+    async requestResponse(msg) {
+        if ((0, level_priority_1.isMessageRelevantForLevel)(msg, this.level) && this.needsApproval(msg)) {
+            this.requestSpy(msg);
+        }
+        return msg.defaultResponse;
+    }
+    needsApproval(msg) {
+        // Return true if the code is unrelated to approval
+        if (!['CDK_TOOLKIT_I5060'].includes(msg.code)) {
+            return true;
+        }
+        switch (this.requireDeployApproval) {
+            case require_approval_1.RequireApproval.NEVER:
+                return false;
+            case require_approval_1.RequireApproval.ANY_CHANGE:
+                return true;
+            case require_approval_1.RequireApproval.BROADENING:
+                return msg.data?.permissionChangeType === 'broadening';
+            default:
+                return true;
+        }
+    }
+}
+exports.TestIoHost = TestIoHost;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/io/private/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Valid reporting categories for messages.
+ */
+export type IoMessageCodeCategory = 'TOOLKIT' | 'SDK' | 'ASSETS' | 'ASSEMBLY';

package/lib/api/io/private/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWYWxpZCByZXBvcnRpbmcgY2F0ZWdvcmllcyBmb3IgbWVzc2FnZXMuXG4gKi9cbmV4cG9ydCB0eXBlIElvTWVzc2FnZUNvZGVDYXRlZ29yeSA9ICdUT09MS0lUJyB8ICdTREsnIHwgJ0FTU0VUUycgfCAnQVNTRU1CTFknO1xuIl19

package/lib/api/io/toolkit-action.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The current action being performed by the CLI. 'none' represents the absence of an action.
+ */
+export type ToolkitAction = 'assembly' | 'bootstrap' | 'synth' | 'list' | 'diff' | 'deploy' | 'rollback' | 'watch' | 'destroy' | 'doctor' | 'gc' | 'import' | 'metadata' | 'init' | 'migrate' | 'refactor';

package/lib/api/io/toolkit-action.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbGtpdC1hY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0b29sa2l0LWFjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgY3VycmVudCBhY3Rpb24gYmVpbmcgcGVyZm9ybWVkIGJ5IHRoZSBDTEkuICdub25lJyByZXByZXNlbnRzIHRoZSBhYnNlbmNlIG9mIGFuIGFjdGlvbi5cbiAqL1xuZXhwb3J0IHR5cGUgVG9vbGtpdEFjdGlvbiA9XG58ICdhc3NlbWJseSdcbnwgJ2Jvb3RzdHJhcCdcbnwgJ3N5bnRoJ1xufCAnbGlzdCdcbnwgJ2RpZmYnXG58ICdkZXBsb3knXG58ICdyb2xsYmFjaydcbnwgJ3dhdGNoJ1xufCAnZGVzdHJveSdcbnwgJ2RvY3RvcidcbnwgJ2djJ1xufCAnaW1wb3J0J1xufCAnbWV0YWRhdGEnXG58ICdpbml0J1xufCAnbWlncmF0ZSdcbnwgJ3JlZmFjdG9yJztcbiJdfQ==

package/lib/api/logs-monitor/find-cloudwatch-logs.d.ts

@@ -0,0 +1,25 @@
+import type { CloudFormationStackArtifact, Environment } from '@aws-cdk/cx-api';
+import type { SDK, SdkProvider } from '../aws-auth/private';
+import type { IoHelper } from '../io/private';
+/**
+ * Configuration needed to monitor CloudWatch Log Groups
+ * found in a given CloudFormation Stack
+ */
+export interface FoundLogGroupsResult {
+    /**
+     * The resolved environment (account/region) that the log
+     * groups are deployed in
+     */
+    readonly env: Environment;
+    /**
+     * The SDK that can be used to read events from the CloudWatch
+     * Log Groups in the given environment
+     */
+    readonly sdk: SDK;
+    /**
+     * The names of the relevant CloudWatch Log Groups
+     * in the given CloudFormation template
+     */
+    readonly logGroupNames: string[];
+}
+export declare function findCloudWatchLogGroups(sdkProvider: SdkProvider, ioHelper: IoHelper, stackArtifact: CloudFormationStackArtifact): Promise<FoundLogGroupsResult>;