@aws-cdk/service-spec-types 0.0.0

package/lib/types/resource.d.ts

@@ -0,0 +1,316 @@
+import { Entity, Reference, Relationship } from '@cdklabs/tskb';
+import { SpecDatabase } from './database';
+export interface Partition extends Entity {
+    readonly partition: string;
+}
+export type HasRegion = Relationship<Partition, Region, {
+    isPrimary?: boolean;
+}>;
+export interface Service extends Entity {
+    /**
+     * The full name of the service including the group prefix, lowercased and hyphenated.
+     *
+     * E.g. `AWS::DynamoDB` -> `aws-dynamodb`
+     *
+     * @example aws-dynamodb
+     */
+    readonly name: string;
+    /**
+     * Only the service part of the name, lowercased.
+     *
+     * E.g. `AWS::DynamoDB` -> `dynamodb`
+     *
+     * @example dynamodb
+     */
+    readonly shortName: string;
+    /**
+     * The shortname of the service in capitalized form
+     *
+     * E.g. `AWS::DynamoDB` -> `DynamoDB`
+     *
+     * @example dynamodb
+     */
+    readonly capitalized: string;
+    /**
+     * The complete cloudformation style namespace of the service
+     *
+     * E.g. `AWS::DynamoDB`
+     *
+     * @example dynamodb
+     */
+    readonly cloudFormationNamespace: string;
+}
+export interface Region extends Entity {
+    readonly name: string;
+    readonly description?: string;
+}
+export interface Documentation extends Entity {
+    readonly markdown: string;
+}
+export interface Resource extends Entity {
+    readonly name: string;
+    readonly cloudFormationType: string;
+    /**
+     * If set, this CloudFormation Transform is required by the resource
+     */
+    cloudFormationTransform?: string;
+    documentation?: string;
+    readonly properties: ResourceProperties;
+    readonly attributes: Record<string, Attribute>;
+    readonly validations?: unknown;
+    identifier?: ResourceIdentifier;
+    isStateful?: boolean;
+    /**
+     * Information about the taggability of this resource
+     *
+     * Undefined if the resource is not taggable.
+     */
+    tagInformation?: TagInformation;
+    /**
+     * Whether changes to this resource need to be scrutinized
+     *
+     * @default ResourceScrutinyType.NONE
+     */
+    scrutinizable?: ResourceScrutinyType;
+}
+export type ResourceProperties = Record<string, Property>;
+export interface TypeDefinition extends Entity {
+    readonly name: string;
+    documentation?: string;
+    readonly properties: ResourceProperties;
+    /**
+     * If true, render this type even if it is unused.
+     */
+    mustRenderForBwCompat?: boolean;
+}
+export interface Property {
+    /**
+     * Description of the property
+     */
+    documentation?: string;
+    /**
+     * Is this property required
+     *
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * The current type of this property
+     */
+    type: PropertyType;
+    /**
+     * An ordered list of previous types of this property in ascending order
+     *
+     * Does not include the current type, use `type` for this.
+     */
+    previousTypes?: PropertyType[];
+    /**
+     * A string representation the default value of this property
+     *
+     * This value is not directly functional; it describes how the underlying resource
+     * will behave if the value is not specified.
+     *
+     * @default - Default unknown
+     */
+    defaultValue?: string;
+    /**
+     * Whether this property is deprecated
+     *
+     * @default - Not deprecated
+     */
+    deprecated?: Deprecation;
+    /**
+     * Whether changes to this property needs to be scrutinized specially
+     *
+     * @default PropertyScrutinyType.NONE
+     */
+    scrutinizable?: PropertyScrutinyType;
+}
+export declare class RichTypedField {
+    private readonly field;
+    constructor(field: Pick<Property, 'type' | 'previousTypes'>);
+    types(): PropertyType[];
+    addPreviousType(type: PropertyType): boolean;
+}
+export declare class RichProperty extends RichTypedField {
+    constructor(property: Property);
+}
+export declare class RichAttribute extends RichTypedField {
+    constructor(attr: Attribute);
+}
+export interface Attribute {
+    documentation?: string;
+    type: PropertyType;
+    /**
+     * An ordered list of previous types of this property in ascending order
+     *
+     * Does not include the current type, use `type` for this.
+     */
+    previousTypes?: PropertyType[];
+}
+export declare enum Deprecation {
+    /**
+     * Not deprecated
+     */
+    NONE = "NONE",
+    /**
+     * Warn about use
+     */
+    WARN = "WARN",
+    /**
+     * Do not emit the value at all
+     *
+     * (Handle properties that were incorrectly added to the spec)
+     */
+    IGNORE = "IGNORE"
+}
+export type PropertyType = PrimitiveType | DefinitionReference | BuiltinTagType | ArrayType<PropertyType> | MapType<PropertyType> | TypeUnion<PropertyType>;
+export type PrimitiveType = StringType | NumberType | IntegerType | BooleanType | JsonType | DateTimeType | NullType | BuiltinTagType;
+export declare function isCollectionType(x: PropertyType): x is ArrayType<any> | MapType<any>;
+export interface TagInformation {
+    /**
+     * Name of the property that holds the tags
+     */
+    readonly tagPropertyName: string;
+    /**
+     * Used to instruct cdk.TagManager how to handle tags
+     */
+    readonly variant: TagVariant;
+}
+export type TagVariant = 'standard' | 'asg' | 'map';
+export interface StringType {
+    readonly type: 'string';
+}
+export interface BuiltinTagType {
+    readonly type: 'tag';
+}
+export interface NumberType {
+    readonly type: 'number';
+}
+export interface IntegerType {
+    readonly type: 'integer';
+}
+export interface BooleanType {
+    readonly type: 'boolean';
+}
+export interface JsonType {
+    readonly type: 'json';
+}
+export interface NullType {
+    readonly type: 'null';
+}
+export interface DateTimeType {
+    readonly type: 'date-time';
+}
+/**
+ * The "legacy" tag type (used in the old resource spec)
+ */
+export interface BuiltinTagType {
+    readonly type: 'tag';
+}
+export interface DefinitionReference {
+    readonly type: 'ref';
+    readonly reference: Reference<TypeDefinition>;
+}
+export interface ArrayType<E> {
+    readonly type: 'array';
+    readonly element: E;
+}
+export interface MapType<E> {
+    readonly type: 'map';
+    readonly element: E;
+}
+export interface TypeUnion<E> {
+    readonly type: 'union';
+    readonly types: E[];
+}
+export type HasResource = Relationship<Service, Resource>;
+export type RegionHasResource = Relationship<Region, Resource>;
+export type RegionHasService = Relationship<Region, Service>;
+export type ResourceDoc = Relationship<Resource, Documentation>;
+export type ServiceInRegion = Relationship<Region, Service>;
+export type ResourceInRegion = Relationship<Region, Resource>;
+export type UsesType = Relationship<Resource, TypeDefinition>;
+export interface ResourceIdentifier extends Entity {
+    readonly arnTemplate?: string;
+    readonly primaryIdentifier?: string[];
+}
+/**
+ * Mark a resource as a resource that needs additional scrutiy when added, removed or changed
+ *
+ * Used to mark resources that represent security policies.
+ */
+export declare enum ResourceScrutinyType {
+    /**
+     * No additional scrutiny
+     */
+    None = "None",
+    /**
+     * An externally attached policy document to a resource
+     *
+     * (Common for SQS, SNS, S3, ...)
+     */
+    ResourcePolicyResource = "ResourcePolicyResource",
+    /**
+     * This is an IAM policy on an identity resource
+     *
+     * (Basically saying: this is AWS::IAM::Policy)
+     */
+    IdentityPolicyResource = "IdentityPolicyResource",
+    /**
+     * This is a Lambda Permission policy
+     */
+    LambdaPermission = "LambdaPermission",
+    /**
+     * An ingress rule object
+     */
+    IngressRuleResource = "IngressRuleResource",
+    /**
+     * A set of egress rules
+     */
+    EgressRuleResource = "EgressRuleResource"
+}
+/**
+ * Mark a property as a property that needs additional scrutiny when it changes
+ *
+ * Used to mark sensitive properties that have security-related implications.
+ */
+export declare enum PropertyScrutinyType {
+    /**
+     * No additional scrutiny
+     */
+    None = "None",
+    /**
+     * This is an IAM policy directly on a resource
+     */
+    InlineResourcePolicy = "InlineResourcePolicy",
+    /**
+     * Either an AssumeRolePolicyDocument or a dictionary of policy documents
+     */
+    InlineIdentityPolicies = "InlineIdentityPolicies",
+    /**
+     * A list of managed policies (on an identity resource)
+     */
+    ManagedPolicies = "ManagedPolicies",
+    /**
+     * A set of ingress rules (on a security group)
+     */
+    IngressRules = "IngressRules",
+    /**
+     * A set of egress rules (on a security group)
+     */
+    EgressRules = "EgressRules"
+}
+export declare class RichPropertyType {
+    private readonly type;
+    constructor(type: PropertyType);
+    equals(rhs: PropertyType): boolean;
+    /**
+     * Whether the current type is JavaScript-equal to the RHS type
+     *
+     * Same as normal equality, but consider `integer` and `number` the same types.
+     */
+    javascriptEquals(rhs: PropertyType): boolean;
+    stringify(db: SpecDatabase): string;
+    sortKey(): string[];
+}

package/lib/types/resource.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichPropertyType = exports.PropertyScrutinyType = exports.ResourceScrutinyType = exports.isCollectionType = exports.Deprecation = exports.RichAttribute = exports.RichProperty = exports.RichTypedField = void 0;
+const sorting_1 = require("../util/sorting");
+class RichTypedField {
+    constructor(field) {
+        this.field = field;
+        if (field === undefined) {
+            throw new Error('Field is undefined');
+        }
+    }
+    types() {
+        var _a;
+        return [...((_a = this.field.previousTypes) !== null && _a !== void 0 ? _a : []), this.field.type];
+    }
+    addPreviousType(type) {
+        const richType = new RichPropertyType(type);
+        // Only add this type if we don't already have it. We are only doing comparisons where 'integer' and 'number'
+        // are treated the same, for all other types we need strict equality. We used to use 'assignableTo' as a
+        // condition, but these types will be rendered in both co- and contravariant positions, and so we really can't
+        // do much better than full equality.
+        if (this.types().some((t) => richType.javascriptEquals(t))) {
+            // Nothing to do, type is already in there.
+            return false;
+        }
+        if (!this.field.previousTypes) {
+            this.field.previousTypes = [];
+        }
+        this.field.previousTypes.unshift(type);
+        return true;
+    }
+}
+exports.RichTypedField = RichTypedField;
+class RichProperty extends RichTypedField {
+    constructor(property) {
+        super(property);
+    }
+}
+exports.RichProperty = RichProperty;
+class RichAttribute extends RichTypedField {
+    constructor(attr) {
+        super(attr);
+    }
+}
+exports.RichAttribute = RichAttribute;
+var Deprecation;
+(function (Deprecation) {
+    /**
+     * Not deprecated
+     */
+    Deprecation["NONE"] = "NONE";
+    /**
+     * Warn about use
+     */
+    Deprecation["WARN"] = "WARN";
+    /**
+     * Do not emit the value at all
+     *
+     * (Handle properties that were incorrectly added to the spec)
+     */
+    Deprecation["IGNORE"] = "IGNORE";
+})(Deprecation = exports.Deprecation || (exports.Deprecation = {}));
+function isCollectionType(x) {
+    return x.type === 'array' || x.type === 'map';
+}
+exports.isCollectionType = isCollectionType;
+/**
+ * Mark a resource as a resource that needs additional scrutiy when added, removed or changed
+ *
+ * Used to mark resources that represent security policies.
+ */
+var ResourceScrutinyType;
+(function (ResourceScrutinyType) {
+    /**
+     * No additional scrutiny
+     */
+    ResourceScrutinyType["None"] = "None";
+    /**
+     * An externally attached policy document to a resource
+     *
+     * (Common for SQS, SNS, S3, ...)
+     */
+    ResourceScrutinyType["ResourcePolicyResource"] = "ResourcePolicyResource";
+    /**
+     * This is an IAM policy on an identity resource
+     *
+     * (Basically saying: this is AWS::IAM::Policy)
+     */
+    ResourceScrutinyType["IdentityPolicyResource"] = "IdentityPolicyResource";
+    /**
+     * This is a Lambda Permission policy
+     */
+    ResourceScrutinyType["LambdaPermission"] = "LambdaPermission";
+    /**
+     * An ingress rule object
+     */
+    ResourceScrutinyType["IngressRuleResource"] = "IngressRuleResource";
+    /**
+     * A set of egress rules
+     */
+    ResourceScrutinyType["EgressRuleResource"] = "EgressRuleResource";
+})(ResourceScrutinyType = exports.ResourceScrutinyType || (exports.ResourceScrutinyType = {}));
+/**
+ * Mark a property as a property that needs additional scrutiny when it changes
+ *
+ * Used to mark sensitive properties that have security-related implications.
+ */
+var PropertyScrutinyType;
+(function (PropertyScrutinyType) {
+    /**
+     * No additional scrutiny
+     */
+    PropertyScrutinyType["None"] = "None";
+    /**
+     * This is an IAM policy directly on a resource
+     */
+    PropertyScrutinyType["InlineResourcePolicy"] = "InlineResourcePolicy";
+    /**
+     * Either an AssumeRolePolicyDocument or a dictionary of policy documents
+     */
+    PropertyScrutinyType["InlineIdentityPolicies"] = "InlineIdentityPolicies";
+    /**
+     * A list of managed policies (on an identity resource)
+     */
+    PropertyScrutinyType["ManagedPolicies"] = "ManagedPolicies";
+    /**
+     * A set of ingress rules (on a security group)
+     */
+    PropertyScrutinyType["IngressRules"] = "IngressRules";
+    /**
+     * A set of egress rules (on a security group)
+     */
+    PropertyScrutinyType["EgressRules"] = "EgressRules";
+})(PropertyScrutinyType = exports.PropertyScrutinyType || (exports.PropertyScrutinyType = {}));
+class RichPropertyType {
+    constructor(type) {
+        this.type = type;
+    }
+    equals(rhs) {
+        switch (this.type.type) {
+            case 'integer':
+            case 'boolean':
+            case 'date-time':
+            case 'json':
+            case 'null':
+            case 'number':
+            case 'string':
+            case 'tag':
+                return rhs.type === this.type.type;
+            case 'array':
+            case 'map':
+                return rhs.type === this.type.type && new RichPropertyType(this.type.element).equals(rhs.element);
+            case 'ref':
+                return rhs.type === 'ref' && this.type.reference.$ref === rhs.reference.$ref;
+            case 'union':
+                const lhsKey = this.sortKey();
+                const rhsKey = new RichPropertyType(rhs).sortKey();
+                return lhsKey.length === rhsKey.length && lhsKey.every((l, i) => l === rhsKey[i]);
+        }
+    }
+    /**
+     * Whether the current type is JavaScript-equal to the RHS type
+     *
+     * Same as normal equality, but consider `integer` and `number` the same types.
+     */
+    javascriptEquals(rhs) {
+        switch (this.type.type) {
+            case 'number':
+            case 'integer':
+                // Widening
+                return rhs.type === 'integer' || rhs.type === 'number';
+            case 'array':
+            case 'map':
+                return rhs.type === this.type.type && new RichPropertyType(this.type.element).javascriptEquals(rhs.element);
+            case 'union':
+                if (rhs.type !== 'union') {
+                    return false;
+                }
+                // Every type in this union needs to be equal one type in RHS
+                return this.type.types.every((t1) => rhs.types.some((t2) => new RichPropertyType(t1).javascriptEquals(t2)));
+            default:
+                // For anything else, need strict equality
+                return this.equals(rhs);
+        }
+    }
+    stringify(db) {
+        switch (this.type.type) {
+            case 'integer':
+            case 'boolean':
+            case 'date-time':
+            case 'json':
+            case 'null':
+            case 'number':
+            case 'string':
+            case 'tag':
+                return this.type.type;
+            case 'array':
+                return `Array<${new RichPropertyType(this.type.element).stringify(db)}>`;
+            case 'map':
+                return `Map<string, ${new RichPropertyType(this.type.element).stringify(db)}>`;
+            case 'ref':
+                const type = db.get('typeDefinition', this.type.reference);
+                return `${type.name}(${this.type.reference.$ref})`;
+            case 'union':
+                return this.type.types.map((t) => new RichPropertyType(t).stringify(db)).join(' | ');
+        }
+    }
+    sortKey() {
+        switch (this.type.type) {
+            case 'integer':
+            case 'boolean':
+            case 'date-time':
+            case 'json':
+            case 'null':
+            case 'number':
+            case 'string':
+            case 'tag':
+                return [this.type.type];
+            case 'array':
+            case 'map':
+                return [this.type.type, ...new RichPropertyType(this.type.element).sortKey()];
+            case 'ref':
+                return [this.type.type, this.type.reference.$ref];
+            case 'union':
+                const typeKeys = this.type.types.map((t) => new RichPropertyType(t).sortKey());
+                typeKeys.sort((0, sorting_1.sortKeyComparator)((x) => x));
+                return [this.type.type, ...typeKeys.flatMap((x) => x)];
+        }
+    }
+}
+exports.RichPropertyType = RichPropertyType;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../src/types/resource.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity, Reference, Relationship } from '@cdklabs/tskb';\nimport { SpecDatabase } from './database';\nimport { sortKeyComparator } from '../util/sorting';\n\nexport interface Partition extends Entity {\n  readonly partition: string;\n}\n\nexport type HasRegion = Relationship<Partition, Region, { isPrimary?: boolean }>;\n\nexport interface Service extends Entity {\n  /**\n   * The full name of the service including the group prefix, lowercased and hyphenated.\n   *\n   * E.g. `AWS::DynamoDB` -> `aws-dynamodb`\n   *\n   * @example aws-dynamodb\n   */\n  readonly name: string;\n  /**\n   * Only the service part of the name, lowercased.\n   *\n   * E.g. `AWS::DynamoDB` -> `dynamodb`\n   *\n   * @example dynamodb\n   */\n  readonly shortName: string;\n  /**\n   * The shortname of the service in capitalized form\n   *\n   * E.g. `AWS::DynamoDB` -> `DynamoDB`\n   *\n   * @example dynamodb\n   */\n  readonly capitalized: string;\n  /**\n   * The complete cloudformation style namespace of the service\n   *\n   * E.g. `AWS::DynamoDB`\n   *\n   * @example dynamodb\n   */\n  readonly cloudFormationNamespace: string;\n}\n\nexport interface Region extends Entity {\n  readonly name: string;\n  readonly description?: string;\n}\n\nexport interface Documentation extends Entity {\n  readonly markdown: string;\n}\n\nexport interface Resource extends Entity {\n  readonly name: string;\n  readonly cloudFormationType: string;\n  /**\n   * If set, this CloudFormation Transform is required by the resource\n   */\n  cloudFormationTransform?: string;\n  documentation?: string;\n  readonly properties: ResourceProperties;\n  readonly attributes: Record<string, Attribute>;\n  readonly validations?: unknown;\n  identifier?: ResourceIdentifier;\n  isStateful?: boolean;\n\n  /**\n   * Information about the taggability of this resource\n   *\n   * Undefined if the resource is not taggable.\n   */\n  tagInformation?: TagInformation;\n\n  /**\n   * Whether changes to this resource need to be scrutinized\n   *\n   * @default ResourceScrutinyType.NONE\n   */\n  scrutinizable?: ResourceScrutinyType;\n}\n\nexport type ResourceProperties = Record<string, Property>;\n\nexport interface TypeDefinition extends Entity {\n  readonly name: string;\n  documentation?: string;\n  readonly properties: ResourceProperties;\n\n  /**\n   * If true, render this type even if it is unused.\n   */\n  mustRenderForBwCompat?: boolean;\n}\n\nexport interface Property {\n  /**\n   * Description of the property\n   */\n  documentation?: string;\n\n  /**\n   * Is this property required\n   *\n   * @default false\n   */\n  required?: boolean;\n\n  /**\n   * The current type of this property\n   */\n  type: PropertyType;\n\n  /**\n   * An ordered list of previous types of this property in ascending order\n   *\n   * Does not include the current type, use `type` for this.\n   */\n  previousTypes?: PropertyType[];\n\n  /**\n   * A string representation the default value of this property\n   *\n   * This value is not directly functional; it describes how the underlying resource\n   * will behave if the value is not specified.\n   *\n   * @default - Default unknown\n   */\n  defaultValue?: string;\n\n  /**\n   * Whether this property is deprecated\n   *\n   * @default - Not deprecated\n   */\n  deprecated?: Deprecation;\n\n  /**\n   * Whether changes to this property needs to be scrutinized specially\n   *\n   * @default PropertyScrutinyType.NONE\n   */\n  scrutinizable?: PropertyScrutinyType;\n}\n\nexport class RichTypedField {\n  constructor(private readonly field: Pick<Property, 'type' | 'previousTypes'>) {\n    if (field === undefined) {\n      throw new Error('Field is undefined');\n    }\n  }\n\n  public types(): PropertyType[] {\n    return [...(this.field.previousTypes ?? []), this.field.type];\n  }\n\n  public addPreviousType(type: PropertyType): boolean {\n    const richType = new RichPropertyType(type);\n\n    // Only add this type if we don't already have it. We are only doing comparisons where 'integer' and 'number'\n    // are treated the same, for all other types we need strict equality. We used to use 'assignableTo' as a\n    // condition, but these types will be rendered in both co- and contravariant positions, and so we really can't\n    // do much better than full equality.\n    if (this.types().some((t) => richType.javascriptEquals(t))) {\n      // Nothing to do, type is already in there.\n      return false;\n    }\n    if (!this.field.previousTypes) {\n      this.field.previousTypes = [];\n    }\n    this.field.previousTypes.unshift(type);\n    return true;\n  }\n}\n\nexport class RichProperty extends RichTypedField {\n  constructor(property: Property) {\n    super(property);\n  }\n}\n\nexport class RichAttribute extends RichTypedField {\n  constructor(attr: Attribute) {\n    super(attr);\n  }\n}\n\nexport interface Attribute {\n  documentation?: string;\n  type: PropertyType;\n  /**\n   * An ordered list of previous types of this property in ascending order\n   *\n   * Does not include the current type, use `type` for this.\n   */\n  previousTypes?: PropertyType[];\n}\n\nexport enum Deprecation {\n  /**\n   * Not deprecated\n   */\n  NONE = 'NONE',\n\n  /**\n   * Warn about use\n   */\n  WARN = 'WARN',\n\n  /**\n   * Do not emit the value at all\n   *\n   * (Handle properties that were incorrectly added to the spec)\n   */\n  IGNORE = 'IGNORE',\n}\n\nexport type PropertyType =\n  | PrimitiveType\n  | DefinitionReference\n  | BuiltinTagType\n  | ArrayType<PropertyType>\n  | MapType<PropertyType>\n  | TypeUnion<PropertyType>;\n\nexport type PrimitiveType =\n  | StringType\n  | NumberType\n  | IntegerType\n  | BooleanType\n  | JsonType\n  | DateTimeType\n  | NullType\n  | BuiltinTagType;\n\nexport function isCollectionType(x: PropertyType): x is ArrayType<any> | MapType<any> {\n  return x.type === 'array' || x.type === 'map';\n}\n\nexport interface TagInformation {\n  /**\n   * Name of the property that holds the tags\n   */\n  readonly tagPropertyName: string;\n\n  /**\n   * Used to instruct cdk.TagManager how to handle tags\n   */\n  readonly variant: TagVariant;\n}\n\nexport type TagVariant = 'standard' | 'asg' | 'map';\n\nexport interface StringType {\n  readonly type: 'string';\n}\nexport interface BuiltinTagType {\n  readonly type: 'tag';\n}\n\nexport interface NumberType {\n  readonly type: 'number';\n}\n\nexport interface IntegerType {\n  readonly type: 'integer';\n}\n\nexport interface BooleanType {\n  readonly type: 'boolean';\n}\n\nexport interface JsonType {\n  readonly type: 'json';\n}\n\nexport interface NullType {\n  readonly type: 'null';\n}\n\nexport interface DateTimeType {\n  readonly type: 'date-time';\n}\n\n/**\n * The \"legacy\" tag type (used in the old resource spec)\n */\nexport interface BuiltinTagType {\n  readonly type: 'tag';\n}\n\nexport interface DefinitionReference {\n  readonly type: 'ref';\n  readonly reference: Reference<TypeDefinition>;\n}\n\nexport interface ArrayType<E> {\n  readonly type: 'array';\n  readonly element: E;\n}\n\nexport interface MapType<E> {\n  readonly type: 'map';\n  readonly element: E;\n}\n\nexport interface TypeUnion<E> {\n  readonly type: 'union';\n  readonly types: E[];\n}\n\nexport type HasResource = Relationship<Service, Resource>;\nexport type RegionHasResource = Relationship<Region, Resource>;\nexport type RegionHasService = Relationship<Region, Service>;\nexport type ResourceDoc = Relationship<Resource, Documentation>;\n\nexport type ServiceInRegion = Relationship<Region, Service>;\nexport type ResourceInRegion = Relationship<Region, Resource>;\n\nexport type UsesType = Relationship<Resource, TypeDefinition>;\n\nexport interface ResourceIdentifier extends Entity {\n  readonly arnTemplate?: string;\n  readonly primaryIdentifier?: string[];\n}\n\n/**\n * Mark a resource as a resource that needs additional scrutiy when added, removed or changed\n *\n * Used to mark resources that represent security policies.\n */\nexport enum ResourceScrutinyType {\n  /**\n   * No additional scrutiny\n   */\n  None = 'None',\n\n  /**\n   * An externally attached policy document to a resource\n   *\n   * (Common for SQS, SNS, S3, ...)\n   */\n  ResourcePolicyResource = 'ResourcePolicyResource',\n\n  /**\n   * This is an IAM policy on an identity resource\n   *\n   * (Basically saying: this is AWS::IAM::Policy)\n   */\n  IdentityPolicyResource = 'IdentityPolicyResource',\n\n  /**\n   * This is a Lambda Permission policy\n   */\n  LambdaPermission = 'LambdaPermission',\n\n  /**\n   * An ingress rule object\n   */\n  IngressRuleResource = 'IngressRuleResource',\n\n  /**\n   * A set of egress rules\n   */\n  EgressRuleResource = 'EgressRuleResource',\n}\n\n/**\n * Mark a property as a property that needs additional scrutiny when it changes\n *\n * Used to mark sensitive properties that have security-related implications.\n */\nexport enum PropertyScrutinyType {\n  /**\n   * No additional scrutiny\n   */\n  None = 'None',\n\n  /**\n   * This is an IAM policy directly on a resource\n   */\n  InlineResourcePolicy = 'InlineResourcePolicy',\n\n  /**\n   * Either an AssumeRolePolicyDocument or a dictionary of policy documents\n   */\n  InlineIdentityPolicies = 'InlineIdentityPolicies',\n\n  /**\n   * A list of managed policies (on an identity resource)\n   */\n  ManagedPolicies = 'ManagedPolicies',\n\n  /**\n   * A set of ingress rules (on a security group)\n   */\n  IngressRules = 'IngressRules',\n\n  /**\n   * A set of egress rules (on a security group)\n   */\n  EgressRules = 'EgressRules',\n}\n\nexport class RichPropertyType {\n  constructor(private readonly type: PropertyType) {}\n\n  public equals(rhs: PropertyType): boolean {\n    switch (this.type.type) {\n      case 'integer':\n      case 'boolean':\n      case 'date-time':\n      case 'json':\n      case 'null':\n      case 'number':\n      case 'string':\n      case 'tag':\n        return rhs.type === this.type.type;\n      case 'array':\n      case 'map':\n        return rhs.type === this.type.type && new RichPropertyType(this.type.element).equals(rhs.element);\n      case 'ref':\n        return rhs.type === 'ref' && this.type.reference.$ref === rhs.reference.$ref;\n      case 'union':\n        const lhsKey = this.sortKey();\n        const rhsKey = new RichPropertyType(rhs).sortKey();\n        return lhsKey.length === rhsKey.length && lhsKey.every((l, i) => l === rhsKey[i]);\n    }\n  }\n\n  /**\n   * Whether the current type is JavaScript-equal to the RHS type\n   *\n   * Same as normal equality, but consider `integer` and `number` the same types.\n   */\n  public javascriptEquals(rhs: PropertyType): boolean {\n    switch (this.type.type) {\n      case 'number':\n      case 'integer':\n        // Widening\n        return rhs.type === 'integer' || rhs.type === 'number';\n\n      case 'array':\n      case 'map':\n        return rhs.type === this.type.type && new RichPropertyType(this.type.element).javascriptEquals(rhs.element);\n\n      case 'union':\n        if (rhs.type !== 'union') {\n          return false;\n        }\n        // Every type in this union needs to be equal one type in RHS\n        return this.type.types.every((t1) => rhs.types.some((t2) => new RichPropertyType(t1).javascriptEquals(t2)));\n\n      default:\n        // For anything else, need strict equality\n        return this.equals(rhs);\n    }\n  }\n\n  public stringify(db: SpecDatabase): string {\n    switch (this.type.type) {\n      case 'integer':\n      case 'boolean':\n      case 'date-time':\n      case 'json':\n      case 'null':\n      case 'number':\n      case 'string':\n      case 'tag':\n        return this.type.type;\n      case 'array':\n        return `Array<${new RichPropertyType(this.type.element).stringify(db)}>`;\n      case 'map':\n        return `Map<string, ${new RichPropertyType(this.type.element).stringify(db)}>`;\n      case 'ref':\n        const type = db.get('typeDefinition', this.type.reference);\n        return `${type.name}(${this.type.reference.$ref})`;\n      case 'union':\n        return this.type.types.map((t) => new RichPropertyType(t).stringify(db)).join(' | ');\n    }\n  }\n\n  public sortKey(): string[] {\n    switch (this.type.type) {\n      case 'integer':\n      case 'boolean':\n      case 'date-time':\n      case 'json':\n      case 'null':\n      case 'number':\n      case 'string':\n      case 'tag':\n        return [this.type.type];\n      case 'array':\n      case 'map':\n        return [this.type.type, ...new RichPropertyType(this.type.element).sortKey()];\n      case 'ref':\n        return [this.type.type, this.type.reference.$ref];\n      case 'union':\n        const typeKeys = this.type.types.map((t) => new RichPropertyType(t).sortKey());\n        typeKeys.sort(sortKeyComparator((x) => x));\n        return [this.type.type, ...typeKeys.flatMap((x) => x)];\n    }\n  }\n}\n"]}

package/lib/util/sorting.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Make a sorting comparator that will sort by a given sort key
+ */
+export declare function sortKeyComparator<A>(keyFn: (x: A) => Array<string | number>): (a: A, b: A) => number;

package/lib/util/sorting.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortKeyComparator = void 0;
+/**
+ * Make a sorting comparator that will sort by a given sort key
+ */
+function sortKeyComparator(keyFn) {
+    return (a, b) => {
+        const ak = keyFn(a);
+        const bk = keyFn(b);
+        for (let i = 0; i < ak.length && i < bk.length; i++) {
+            const av = ak[i];
+            const bv = bk[i];
+            let diff = 0;
+            if (typeof av === 'number' && typeof bv === 'number') {
+                diff = av - bv;
+            }
+            else if (typeof av === 'string' && typeof bv === 'string') {
+                diff = av.localeCompare(bv);
+            }
+            if (diff !== 0) {
+                return diff;
+            }
+        }
+        return bk.length - ak.length;
+    };
+}
+exports.sortKeyComparator = sortKeyComparator;
+//# sourceMappingURL=data:application/json;base64,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