construct-hub 0.2.3 → 0.2.7

package/API.md

@@ -323,6 +323,18 @@ The package sources to register with this ConstructHub instance.
 
 ---
 
+##### `packageTags`<sup>Optional</sup> <a name="construct-hub.ConstructHubProps.property.packageTags"></a>
+
+```typescript
+public readonly packageTags: PackageTag[];
+```
+
+- *Type:* [`construct-hub.PackageTag`](#construct-hub.PackageTag)[]
+
+Configuration for custom package tags.
+
+---
+
 ### DenyListMap <a name="construct-hub.DenyListMap"></a>
 
 The contents of the deny list file in S3.
@@ -701,6 +713,155 @@ An optional list of linked resources to be displayed on the monitoring dashboard
 
 ---
 
+### PackageTag <a name="construct-hub.PackageTag"></a>
+
+Configuration for applying custom tags to relevant packages.
+
+Custom tags are
+displayed on the package details page, and can be used for searching.
+
+#### Initializer <a name="[object Object].Initializer"></a>
+
+```typescript
+import { PackageTag } from 'construct-hub'
+
+const packageTag: PackageTag = { ... }
+```
+
+##### `condition`<sup>Required</sup> <a name="construct-hub.PackageTag.property.condition"></a>
+
+```typescript
+public readonly condition: TagCondition;
+```
+
+- *Type:* [`construct-hub.TagCondition`](#construct-hub.TagCondition)
+
+The description of the logic that dictates whether the package has the tag applied.
+
+---
+
+##### `label`<sup>Required</sup> <a name="construct-hub.PackageTag.property.label"></a>
+
+```typescript
+public readonly label: string;
+```
+
+- *Type:* `string`
+
+The label for the tag being applied.
+
+---
+
+##### `color`<sup>Optional</sup> <a name="construct-hub.PackageTag.property.color"></a>
+
+```typescript
+public readonly color: string;
+```
+
+- *Type:* `string`
+
+The hex value string for the color of the tag when displayed.
+
+---
+
+### PackageTagConfig <a name="construct-hub.PackageTagConfig"></a>
+
+Serialized tag declaration to be passed to lambdas via environment variables.
+
+#### Initializer <a name="[object Object].Initializer"></a>
+
+```typescript
+import { PackageTagConfig } from 'construct-hub'
+
+const packageTagConfig: PackageTagConfig = { ... }
+```
+
+##### `condition`<sup>Required</sup> <a name="construct-hub.PackageTagConfig.property.condition"></a>
+
+```typescript
+public readonly condition: TagConditionConfig;
+```
+
+- *Type:* [`construct-hub.TagConditionConfig`](#construct-hub.TagConditionConfig)
+
+---
+
+##### `label`<sup>Required</sup> <a name="construct-hub.PackageTagConfig.property.label"></a>
+
+```typescript
+public readonly label: string;
+```
+
+- *Type:* `string`
+
+The label for the tag being applied.
+
+---
+
+##### `color`<sup>Optional</sup> <a name="construct-hub.PackageTagConfig.property.color"></a>
+
+```typescript
+public readonly color: string;
+```
+
+- *Type:* `string`
+
+The hex value string for the color of the tag when displayed.
+
+---
+
+### TagConditionConfig <a name="construct-hub.TagConditionConfig"></a>
+
+Serialized config for a tag condition.
+
+#### Initializer <a name="[object Object].Initializer"></a>
+
+```typescript
+import { TagConditionConfig } from 'construct-hub'
+
+const tagConditionConfig: TagConditionConfig = { ... }
+```
+
+##### `type`<sup>Required</sup> <a name="construct-hub.TagConditionConfig.property.type"></a>
+
+```typescript
+public readonly type: TagConditionLogicType;
+```
+
+- *Type:* [`construct-hub.TagConditionLogicType`](#construct-hub.TagConditionLogicType)
+
+---
+
+##### `children`<sup>Optional</sup> <a name="construct-hub.TagConditionConfig.property.children"></a>
+
+```typescript
+public readonly children: TagConditionConfig[];
+```
+
+- *Type:* [`construct-hub.TagConditionConfig`](#construct-hub.TagConditionConfig)[]
+
+---
+
+##### `key`<sup>Optional</sup> <a name="construct-hub.TagConditionConfig.property.key"></a>
+
+```typescript
+public readonly key: string[];
+```
+
+- *Type:* `string`[]
+
+---
+
+##### `value`<sup>Optional</sup> <a name="construct-hub.TagConditionConfig.property.value"></a>
+
+```typescript
+public readonly value: string;
+```
+
+- *Type:* `string`
+
+---
+
 ## Classes <a name="Classes"></a>
 
 ### SpdxLicense <a name="construct-hub.SpdxLicense"></a>
@@ -5256,6 +5417,121 @@ Zope Public License 2.1.
 
 ---
 
+### TagCondition <a name="construct-hub.TagCondition"></a>
+
+Condition for applying a custom tag to a package.
+
+#### Initializers <a name="construct-hub.TagCondition.Initializer"></a>
+
+```typescript
+import { TagCondition } from 'construct-hub'
+
+new TagCondition()
+```
+
+#### Methods <a name="Methods"></a>
+
+##### `bind` <a name="construct-hub.TagCondition.bind"></a>
+
+```typescript
+public bind()
+```
+
+#### Static Functions <a name="Static Functions"></a>
+
+##### `and` <a name="construct-hub.TagCondition.and"></a>
+
+```typescript
+import { TagCondition } from 'construct-hub'
+
+TagCondition.and(conds: TagCondition)
+```
+
+###### `conds`<sup>Required</sup> <a name="construct-hub.TagCondition.parameter.conds"></a>
+
+- *Type:* [`construct-hub.TagCondition`](#construct-hub.TagCondition)
+
+---
+
+##### `field` <a name="construct-hub.TagCondition.field"></a>
+
+```typescript
+import { TagCondition } from 'construct-hub'
+
+TagCondition.field(keys: string)
+```
+
+###### `keys`<sup>Required</sup> <a name="construct-hub.TagCondition.parameter.keys"></a>
+
+- *Type:* `string`
+
+---
+
+##### `not` <a name="construct-hub.TagCondition.not"></a>
+
+```typescript
+import { TagCondition } from 'construct-hub'
+
+TagCondition.not(conds: TagCondition)
+```
+
+###### `conds`<sup>Required</sup> <a name="construct-hub.TagCondition.parameter.conds"></a>
+
+- *Type:* [`construct-hub.TagCondition`](#construct-hub.TagCondition)
+
+---
+
+##### `or` <a name="construct-hub.TagCondition.or"></a>
+
+```typescript
+import { TagCondition } from 'construct-hub'
+
+TagCondition.or(conds: TagCondition)
+```
+
+###### `conds`<sup>Required</sup> <a name="construct-hub.TagCondition.parameter.conds"></a>
+
+- *Type:* [`construct-hub.TagCondition`](#construct-hub.TagCondition)
+
+---
+
+
+
+### TagConditionField <a name="construct-hub.TagConditionField"></a>
+
+Target a field to use in logic to dictate whether a tag is relevant.
+
+#### Initializers <a name="construct-hub.TagConditionField.Initializer"></a>
+
+```typescript
+import { TagConditionField } from 'construct-hub'
+
+new TagConditionField(field: string[])
+```
+
+##### `field`<sup>Required</sup> <a name="construct-hub.TagConditionField.parameter.field"></a>
+
+- *Type:* `string`[]
+
+---
+
+#### Methods <a name="Methods"></a>
+
+##### `eq` <a name="construct-hub.TagConditionField.eq"></a>
+
+```typescript
+public eq(value: any)
+```
+
+###### `value`<sup>Required</sup> <a name="construct-hub.TagConditionField.parameter.value"></a>
+
+- *Type:* `any`
+
+---
+
+
+
+
 ## Protocols <a name="Protocols"></a>
 
 ### IDenyList <a name="construct-hub.IDenyList"></a>
@@ -5383,3 +5659,28 @@ the id of the external connection (i.e: `public:npmjs`).
 ---
 
 
+## Enums <a name="Enums"></a>
+
+### TagConditionLogicType <a name="TagConditionLogicType"></a>
+
+Logic operators for performing specific conditional logic.
+
+#### `AND` <a name="construct-hub.TagConditionLogicType.AND"></a>
+
+---
+
+
+#### `OR` <a name="construct-hub.TagConditionLogicType.OR"></a>
+
+---
+
+
+#### `NOT` <a name="construct-hub.TagConditionLogicType.NOT"></a>
+
+---
+
+
+#### `EQUALS` <a name="construct-hub.TagConditionLogicType.EQUALS"></a>
+
+---
+

package/README.md

@@ -164,6 +164,57 @@ you may set the `isolateLambdas` setting to `false`.
 There are a number of customizations available in order to make your private
 construct hub better tailored to your organization.
 
+#### Package Tags
+
+Configuring package tags allows you to compute additional labels to be applied
+to packages. These can be used to indicate to users which packages are owned by
+trusted organizations, or any other arbitrary conditions, and can be referenced
+while searching.
+
+For example:
+```ts
+new ConstructHub(this, "ConstructHub", {
+  ...myProps,
+  packageTags: [{
+    label: 'Official',
+    color: '#00FF00',
+    condition: TagCondition.field('name').eq('construct-hub'),
+  }]
+});
+```
+
+The above example will result in packages with the `name` of `construct-hub` to
+receive the `Official` tag, which is colored green.
+
+Combinations of conditions are also supported:
+```ts
+new ConstructHub(this, "ConstructHub", {
+  ...myProps,
+  packageTags: [{
+    label: 'Official',
+    color: '#00FF00',
+    condition: TagCondition.or(
+      TagCondition.field('name').eq('construct-hub'),
+      TagCondition.field('name').eq('construct-hub-webapp'),
+    ),
+  }]
+});
+
+// or more succintly if you have a long list
+condition: TagCondition.or(
+  ...['construct-hub', 'construct-hub-webapp', '...',]
+    .map(name => TagCondition.field('name').eq(name))
+),
+```
+
+You can assert against any value within package json including nested ones.
+```ts
+TagCondition.field('constructHub', 'nested', 'key').eq('value');
+
+// checks
+packageJson?.constructHub?.nested?.key === value;
+```
+
 #### Package Links
 
 Configuring package links allows you to replace the `Repository`, `License`,

package/lib/backend/ingestion/index.d.ts

@@ -6,6 +6,7 @@ import { IBucket } from '@aws-cdk/aws-s3';
 import { IQueue } from '@aws-cdk/aws-sqs';
 import { Construct, Duration } from '@aws-cdk/core';
 import { Monitoring } from '../../monitoring';
+import { PackageTagConfig } from '../../package-tag';
 import type { PackageLinkConfig } from '../../webapp';
 import { Orchestration } from '../orchestration';
 export interface IngestionProps {
@@ -32,6 +33,10 @@ export interface IngestionProps {
      * Configuration for custom package page links.
      */
     readonly packageLinks?: PackageLinkConfig[];
+    /**
+     * Serialized configuration for custom package tags.
+     */
+    readonly packageTags?: PackageTagConfig[];
 }
 /**
  * The ingestion function receives messages from discovery integrations and

package/lib/backend/ingestion/index.js

@@ -20,7 +20,7 @@ const ingestion_1 = require("./ingestion");
  */
 class Ingestion extends core_1.Construct {
     constructor(scope, id, props) {
-        var _a, _b;
+        var _a, _b, _c;
         super(scope, id);
         this.queueRetentionPeriod = core_1.Duration.days(14);
         this.deadLetterQueue = new aws_sqs_1.Queue(this, 'DLQ', {
@@ -43,8 +43,9 @@ class Ingestion extends core_1.Construct {
                 BUCKET_NAME: props.bucket.bucketName,
                 STATE_MACHINE_ARN: props.orchestration.stateMachine.stateMachineArn,
                 PACKAGE_LINKS: JSON.stringify((_a = props.packageLinks) !== null && _a !== void 0 ? _a : []),
+                PACKAGE_TAGS: JSON.stringify((_b = props.packageTags) !== null && _b !== void 0 ? _b : []),
             },
-            logRetention: (_b = props.logRetention) !== null && _b !== void 0 ? _b : aws_logs_1.RetentionDays.TEN_YEARS,
+            logRetention: (_c = props.logRetention) !== null && _c !== void 0 ? _c : aws_logs_1.RetentionDays.TEN_YEARS,
             memorySize: 10240,
             timeout: core_1.Duration.minutes(15),
             tracing: aws_lambda_1.Tracing.ACTIVE,
@@ -146,4 +147,4 @@ class Ingestion extends core_1.Construct {
     }
 }
 exports.Ingestion = Ingestion;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/backend/ingestion/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComparisonOperator, MathExpression, Metric, MetricOptions, Statistic, TreatMissingData } from '@aws-cdk/aws-cloudwatch';\nimport { IGrantable, IPrincipal } from '@aws-cdk/aws-iam';\nimport { IFunction, Tracing } from '@aws-cdk/aws-lambda';\nimport { SqsEventSource } from '@aws-cdk/aws-lambda-event-sources';\nimport { RetentionDays } from '@aws-cdk/aws-logs';\nimport { IBucket } from '@aws-cdk/aws-s3';\nimport { IQueue, Queue, QueueEncryption } from '@aws-cdk/aws-sqs';\nimport { Construct, Duration } from '@aws-cdk/core';\nimport { lambdaFunctionUrl, sqsQueueUrl } from '../../deep-link';\nimport { Monitoring } from '../../monitoring';\nimport { RUNBOOK_URL } from '../../runbook-url';\nimport type { PackageLinkConfig } from '../../webapp';\nimport { Orchestration } from '../orchestration';\nimport { MetricName, METRICS_NAMESPACE } from './constants';\nimport { Ingestion as Handler } from './ingestion';\n\nexport interface IngestionProps {\n  /**\n   * The bucket in which ingested objects are due to be inserted.\n   */\n  readonly bucket: IBucket;\n\n  /**\n   * The monitoring handler to register alarms with.\n   */\n  readonly monitoring: Monitoring;\n\n  /**\n   * The backend orchestration to invoke once the package metadata has been\n   * successfully registered.\n   */\n  readonly orchestration: Orchestration;\n\n  /**\n   * How long to retain the CloudWatch logs.\n   *\n   * @default RetentionDays.TEN_YEARS\n   */\n  readonly logRetention?: RetentionDays;\n\n  /**\n   * Configuration for custom package page links.\n   */\n  readonly packageLinks?: PackageLinkConfig[];\n}\n\n/**\n * The ingestion function receives messages from discovery integrations and\n * processes their payloads into the provided S3 Bucket.\n *\n * This function is also an `IGrantable`, so that it can be granted permissions\n * to read from the source S3 buckets.\n */\nexport class Ingestion extends Construct implements IGrantable {\n  public readonly grantPrincipal: IPrincipal;\n\n  /**\n   * The SQS queue that triggers the ingestion function.\n   */\n  public readonly queue: IQueue;\n\n  /**\n   * The ingestion dead letter queue, which will hold messages that failed\n   * ingestion one too many times, so that poison pills don't endlessly consume\n   * resources.\n   */\n  public readonly deadLetterQueue: IQueue;\n\n  public readonly queueRetentionPeriod = Duration.days(14);\n\n  public readonly function: IFunction;\n\n  public constructor(scope: Construct, id: string, props: IngestionProps) {\n    super(scope, id);\n\n    this.deadLetterQueue = new Queue(this, 'DLQ', {\n      encryption: QueueEncryption.KMS_MANAGED,\n      retentionPeriod: this.queueRetentionPeriod,\n      visibilityTimeout: Duration.minutes(15),\n    });\n\n    this.queue = new Queue(this, 'Queue', {\n      deadLetterQueue: {\n        maxReceiveCount: 5,\n        queue: this.deadLetterQueue,\n      },\n      encryption: QueueEncryption.KMS_MANAGED,\n      retentionPeriod: this.queueRetentionPeriod,\n      visibilityTimeout: Duration.minutes(15),\n    });\n\n    const handler = new Handler(this, 'Default', {\n      description: '[ConstructHub/Ingestion] Ingests new package versions into the Construct Hub',\n      environment: {\n        BUCKET_NAME: props.bucket.bucketName,\n        STATE_MACHINE_ARN: props.orchestration.stateMachine.stateMachineArn,\n        PACKAGE_LINKS: JSON.stringify(props.packageLinks ?? []),\n      },\n      logRetention: props.logRetention ?? RetentionDays.TEN_YEARS,\n      memorySize: 10_240, // Currently the maximum possible setting\n      timeout: Duration.minutes(15),\n      tracing: Tracing.ACTIVE,\n    });\n    this.function = handler;\n\n    props.bucket.grantWrite(this.function);\n    props.orchestration.stateMachine.grantStartExecution(this.function);\n\n    this.function.addEventSource(new SqsEventSource(this.queue, { batchSize: 1 }));\n    // This event source is disabled, and can be used to re-process dead-letter-queue messages\n    this.function.addEventSource(new SqsEventSource(this.deadLetterQueue, { batchSize: 1, enabled: false }));\n\n    this.grantPrincipal = this.function.grantPrincipal;\n\n    props.monitoring.addHighSeverityAlarm(\n      'Ingestion Dead-Letter Queue not empty',\n      new MathExpression({\n        expression: 'm1 + m2',\n        usingMetrics: {\n          m1: this.deadLetterQueue.metricApproximateNumberOfMessagesVisible({ period: Duration.minutes(1) }),\n          m2: this.deadLetterQueue.metricApproximateNumberOfMessagesNotVisible({ period: Duration.minutes(1) }),\n        },\n      }).createAlarm(this, 'DLQAlarm', {\n        alarmName: `${this.node.path}/DLQNotEmpty`,\n        alarmDescription: [\n          'The dead-letter queue for the Ingestion function is not empty!',\n          '',\n          `RunBook: ${RUNBOOK_URL}`,\n          '',\n          `Direct link to the queue: ${sqsQueueUrl(this.deadLetterQueue)}`,\n          `Direct link to the function: ${lambdaFunctionUrl(this.function)}`,\n        ].join('\\n'),\n        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: 1,\n        threshold: 1,\n        // SQS does not emit metrics if the queue has been empty for a while, which is GOOD.\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n      }),\n    );\n    props.monitoring.addHighSeverityAlarm(\n      'Ingestion failures',\n      this.function.metricErrors().createAlarm(this, 'FailureAlarm', {\n        alarmName: `${this.node.path}/Failure`,\n        alarmDescription: [\n          'The Ingestion function is failing!',\n          '',\n          `RunBook: ${RUNBOOK_URL}`,\n          '',\n          `Direct link to the function: ${lambdaFunctionUrl(this.function)}`,\n        ].join('\\n'),\n        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: 2,\n        threshold: 1,\n        // Lambda only emits metrics when the function is invoked. No invokation => no errors.\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n      }),\n    );\n  }\n\n  public metricFoundLicenseFile(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.FOUND_LICENSE_FILE,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricIneligibleLicense(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INELIGIBLE_LICENSE,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricInvalidAssembly(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INVALID_ASSEMBLY,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricInvalidTarball(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INVALID_TARBALL,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  /**\n   * This metrics is the total count of packages that were rejected due to\n   * mismatched identity (name, version, license) between the `package.json`\n   * file and te `.jsii` attribute.\n   */\n  public metricMismatchedIdentityRejections(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.MISMATCHED_IDENTITY_REJECTIONS,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/backend/ingestion/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComparisonOperator, MathExpression, Metric, MetricOptions, Statistic, TreatMissingData } from '@aws-cdk/aws-cloudwatch';\nimport { IGrantable, IPrincipal } from '@aws-cdk/aws-iam';\nimport { IFunction, Tracing } from '@aws-cdk/aws-lambda';\nimport { SqsEventSource } from '@aws-cdk/aws-lambda-event-sources';\nimport { RetentionDays } from '@aws-cdk/aws-logs';\nimport { IBucket } from '@aws-cdk/aws-s3';\nimport { IQueue, Queue, QueueEncryption } from '@aws-cdk/aws-sqs';\nimport { Construct, Duration } from '@aws-cdk/core';\nimport { lambdaFunctionUrl, sqsQueueUrl } from '../../deep-link';\nimport { Monitoring } from '../../monitoring';\nimport { PackageTagConfig } from '../../package-tag';\nimport { RUNBOOK_URL } from '../../runbook-url';\nimport type { PackageLinkConfig } from '../../webapp';\nimport { Orchestration } from '../orchestration';\nimport { MetricName, METRICS_NAMESPACE } from './constants';\nimport { Ingestion as Handler } from './ingestion';\n\nexport interface IngestionProps {\n  /**\n   * The bucket in which ingested objects are due to be inserted.\n   */\n  readonly bucket: IBucket;\n\n  /**\n   * The monitoring handler to register alarms with.\n   */\n  readonly monitoring: Monitoring;\n\n  /**\n   * The backend orchestration to invoke once the package metadata has been\n   * successfully registered.\n   */\n  readonly orchestration: Orchestration;\n\n  /**\n   * How long to retain the CloudWatch logs.\n   *\n   * @default RetentionDays.TEN_YEARS\n   */\n  readonly logRetention?: RetentionDays;\n\n  /**\n   * Configuration for custom package page links.\n   */\n  readonly packageLinks?: PackageLinkConfig[];\n\n  /**\n   * Serialized configuration for custom package tags.\n   */\n  readonly packageTags?: PackageTagConfig[];\n}\n\n/**\n * The ingestion function receives messages from discovery integrations and\n * processes their payloads into the provided S3 Bucket.\n *\n * This function is also an `IGrantable`, so that it can be granted permissions\n * to read from the source S3 buckets.\n */\nexport class Ingestion extends Construct implements IGrantable {\n  public readonly grantPrincipal: IPrincipal;\n\n  /**\n   * The SQS queue that triggers the ingestion function.\n   */\n  public readonly queue: IQueue;\n\n  /**\n   * The ingestion dead letter queue, which will hold messages that failed\n   * ingestion one too many times, so that poison pills don't endlessly consume\n   * resources.\n   */\n  public readonly deadLetterQueue: IQueue;\n\n  public readonly queueRetentionPeriod = Duration.days(14);\n\n  public readonly function: IFunction;\n\n  public constructor(scope: Construct, id: string, props: IngestionProps) {\n    super(scope, id);\n\n    this.deadLetterQueue = new Queue(this, 'DLQ', {\n      encryption: QueueEncryption.KMS_MANAGED,\n      retentionPeriod: this.queueRetentionPeriod,\n      visibilityTimeout: Duration.minutes(15),\n    });\n\n    this.queue = new Queue(this, 'Queue', {\n      deadLetterQueue: {\n        maxReceiveCount: 5,\n        queue: this.deadLetterQueue,\n      },\n      encryption: QueueEncryption.KMS_MANAGED,\n      retentionPeriod: this.queueRetentionPeriod,\n      visibilityTimeout: Duration.minutes(15),\n    });\n\n    const handler = new Handler(this, 'Default', {\n      description: '[ConstructHub/Ingestion] Ingests new package versions into the Construct Hub',\n      environment: {\n        BUCKET_NAME: props.bucket.bucketName,\n        STATE_MACHINE_ARN: props.orchestration.stateMachine.stateMachineArn,\n        PACKAGE_LINKS: JSON.stringify(props.packageLinks ?? []),\n        PACKAGE_TAGS: JSON.stringify(props.packageTags ?? []),\n      },\n      logRetention: props.logRetention ?? RetentionDays.TEN_YEARS,\n      memorySize: 10_240, // Currently the maximum possible setting\n      timeout: Duration.minutes(15),\n      tracing: Tracing.ACTIVE,\n    });\n    this.function = handler;\n\n    props.bucket.grantWrite(this.function);\n    props.orchestration.stateMachine.grantStartExecution(this.function);\n\n    this.function.addEventSource(new SqsEventSource(this.queue, { batchSize: 1 }));\n    // This event source is disabled, and can be used to re-process dead-letter-queue messages\n    this.function.addEventSource(new SqsEventSource(this.deadLetterQueue, { batchSize: 1, enabled: false }));\n\n    this.grantPrincipal = this.function.grantPrincipal;\n\n    props.monitoring.addHighSeverityAlarm(\n      'Ingestion Dead-Letter Queue not empty',\n      new MathExpression({\n        expression: 'm1 + m2',\n        usingMetrics: {\n          m1: this.deadLetterQueue.metricApproximateNumberOfMessagesVisible({ period: Duration.minutes(1) }),\n          m2: this.deadLetterQueue.metricApproximateNumberOfMessagesNotVisible({ period: Duration.minutes(1) }),\n        },\n      }).createAlarm(this, 'DLQAlarm', {\n        alarmName: `${this.node.path}/DLQNotEmpty`,\n        alarmDescription: [\n          'The dead-letter queue for the Ingestion function is not empty!',\n          '',\n          `RunBook: ${RUNBOOK_URL}`,\n          '',\n          `Direct link to the queue: ${sqsQueueUrl(this.deadLetterQueue)}`,\n          `Direct link to the function: ${lambdaFunctionUrl(this.function)}`,\n        ].join('\\n'),\n        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: 1,\n        threshold: 1,\n        // SQS does not emit metrics if the queue has been empty for a while, which is GOOD.\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n      }),\n    );\n    props.monitoring.addHighSeverityAlarm(\n      'Ingestion failures',\n      this.function.metricErrors().createAlarm(this, 'FailureAlarm', {\n        alarmName: `${this.node.path}/Failure`,\n        alarmDescription: [\n          'The Ingestion function is failing!',\n          '',\n          `RunBook: ${RUNBOOK_URL}`,\n          '',\n          `Direct link to the function: ${lambdaFunctionUrl(this.function)}`,\n        ].join('\\n'),\n        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: 2,\n        threshold: 1,\n        // Lambda only emits metrics when the function is invoked. No invokation => no errors.\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n      }),\n    );\n  }\n\n  public metricFoundLicenseFile(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.FOUND_LICENSE_FILE,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricIneligibleLicense(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INELIGIBLE_LICENSE,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricInvalidAssembly(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INVALID_ASSEMBLY,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  public metricInvalidTarball(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.INVALID_TARBALL,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n\n  /**\n   * This metrics is the total count of packages that were rejected due to\n   * mismatched identity (name, version, license) between the `package.json`\n   * file and te `.jsii` attribute.\n   */\n  public metricMismatchedIdentityRejections(opts?: MetricOptions): Metric {\n    return new Metric({\n      period: Duration.minutes(5),\n      statistic: Statistic.SUM,\n      ...opts,\n      metricName: MetricName.MISMATCHED_IDENTITY_REJECTIONS,\n      namespace: METRICS_NAMESPACE,\n    });\n  }\n}\n"]}

package/lib/backend/ingestion/ingestion.bundle/index.js

@@ -25,6 +25,18 @@ var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }
 var __require = typeof require !== "undefined" ? require : (x) => {
   throw new Error('Dynamic require of "' + x + '" is not supported');
 };
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -16114,6 +16126,35 @@ function integrity(input, tarball, alg = ((_b) => (_b = ((_a) => (_a = input.int
   return `${alg}-${hash.digest("base64")}`;
 }
 
+// src/package-tag/index.ts
+var TagConditionLogicType;
+(function(TagConditionLogicType2) {
+  TagConditionLogicType2["AND"] = "AND";
+  TagConditionLogicType2["OR"] = "OR";
+  TagConditionLogicType2["NOT"] = "NOT";
+  TagConditionLogicType2["EQUALS"] = "EQUALS";
+})(TagConditionLogicType || (TagConditionLogicType = {}));
+
+// src/backend/shared/tags.ts
+function isTagApplicable(config, pkg) {
+  var _a, _b, _c, _d, _e, _f;
+  if (config.type === TagConditionLogicType.AND) {
+    return (_b = (_a = config.children) == null ? void 0 : _a.reduce((accum, cond) => accum && isTagApplicable(cond, pkg), true)) != null ? _b : true;
+  } else if (config.type === TagConditionLogicType.OR) {
+    return (_d = (_c = config.children) == null ? void 0 : _c.reduce((accum, cond) => accum || isTagApplicable(cond, pkg), false)) != null ? _d : true;
+  } else if (config.type === TagConditionLogicType.NOT) {
+    const cond = (_e = config.children) == null ? void 0 : _e[0];
+    if (!cond) {
+      throw new Error("NOT logical operator requires a single condition");
+    }
+    return !isTagApplicable(cond, pkg);
+  } else if (config.type === TagConditionLogicType.EQUALS) {
+    const val = (_f = config.key) == null ? void 0 : _f.reduce((accum, key) => accum ? accum[key] : void 0, pkg);
+    return val === config.value;
+  }
+  return false;
+}
+
 // src/backend/shared/tarball.lambda-shared.ts
 var import_zlib = __toModule(require("zlib"));
 var import_tar_stream = __toModule(require_tar_stream());
@@ -16189,6 +16230,7 @@ var handler = (0, import_aws_embedded_metrics.metricScope)((metrics) => async (e
   const BUCKET_NAME = requireEnv("BUCKET_NAME");
   const STATE_MACHINE_ARN = requireEnv("STATE_MACHINE_ARN");
   const PACKAGE_LINKS = requireEnv("PACKAGE_LINKS");
+  const PACKAGE_TAGS = requireEnv("PACKAGE_TAGS");
   const result = new Array();
   for (const record of (_a = event.Records) != null ? _a : []) {
     const payload = JSON.parse(record.body);
@@ -16233,12 +16275,13 @@ var handler = (0, import_aws_embedded_metrics.metricScope)((metrics) => async (e
       metrics.putMetric(MetricName.INVALID_ASSEMBLY, 1, import_aws_embedded_metrics.Unit.Count);
       return;
     }
+    const packageJsonObj = JSON.parse(packageJson.toString("utf-8"));
     const {
       name: packageJsonName,
       version: packageJsonVersion,
       license: packageJsonLicense,
       constructHub
-    } = JSON.parse(packageJson.toString("utf-8"));
+    } = packageJsonObj;
     if (packageJsonName !== packageName || packageJsonVersion !== packageVersion || packageJsonLicense !== packageLicense) {
       console.log(`Ignoring package with mismatched name, version, and/or license (${packageJsonName}@${packageJsonVersion} is ${packageJsonLicense} !== ${packageName}@${packageVersion} is ${packageLicense})`);
       metrics.putMetric(MetricName.MISMATCHED_IDENTITY_REJECTIONS, 1, import_aws_embedded_metrics.Unit.Count);
@@ -16258,10 +16301,19 @@ var handler = (0, import_aws_embedded_metrics.metricScope)((metrics) => async (e
       }
       return __spreadProps(__spreadValues({}, accum), { [configKey]: pkgValue });
     }, {});
+    const packageTagsConfig = JSON.parse(PACKAGE_TAGS);
+    const packageTags = packageTagsConfig.reduce((accum, tagConfig) => {
+      const _a2 = tagConfig, { condition } = _a2, tagData = __objRest(_a2, ["condition"]);
+      if (isTagApplicable(condition, packageJsonObj)) {
+        return [...accum, tagData];
+      }
+      return accum;
+    }, []);
     const metadata = {
       date: payload.time,
       licenseText: licenseText == null ? void 0 : licenseText.toString("utf-8"),
-      packageLinks
+      packageLinks,
+      packageTags
     };
     const { assemblyKey, metadataKey, packageKey } = getObjectKeys(packageName, packageVersion);
     console.log(`Writing assembly at ${assemblyKey}`);